Dia dhuit! Le déanaí, eisíodh go leor uirlisí uathoibrithe fionnuara chun íomhánna Docker a thógáil agus le himscaradh chuig Kubernetes. Maidir leis seo, chinn mé imirt timpeall le GitLab, staidéar críochnúil a dhéanamh ar a chumais agus, ar ndóigh, an phíblíne a chur ar bun.

Ba é an suíomh Gréasáin a spreag an obair seo cubernetes.io, a ghintear ó cóid foinse go huathoibríoch, agus maidir le gach iarratas comhthiomsaithe a sheoltar, gineann an róbat leagan réamhamhairc den láithreán go huathoibríoch le do chuid athruithe agus cuireann sé nasc ar fáil le breathnú air.

Rinne mé iarracht próiseas den chineál céanna a thógáil ón tús, ach tógtha go hiomlán ar Gitlab CI agus uirlisí saor in aisce a bhfuil taithí agam orthu chun feidhmchláir a imscaradh chuig Kubernetes. Inniu inseoidh mé níos mó duit mar gheall orthu ar deireadh.

Pléifidh an t-alt uirlisí mar:
Hugo, qbec, cailiocht, git-crypt и GitLab CI le cruthú timpeallachtaí dinimiciúla.

Clár ábhair

1. Buail le Hugo
2. An Dockerfile á ullmhú
3. aithne a chur ar kaniko
4. Ag cur aithne ar qbec
5. Ag iarraidh Gitlab-runner le Kubernetes-seiceadóir
6. Ag imscaradh cairteacha Helm le qbec
7. Ag tabhairt isteach git-crypt
8. Íomhá bosca uirlisí á cruthú
9. Ár gcéad phíblíne agus cóimeáil íomhánna de réir clibeanna
10. Uathoibriú imlonnaithe
11. Déantáin agus cóimeáil agus tú ag brú chun máistreacht
12. Timpeallachtaí dinimiciúla
13. Aipeanna Athbhreithnithe

1. Ag cur aithne ar Hugo

Mar shampla dár dtionscadal, déanfaimid iarracht suíomh foilsitheoireachta doiciméad a chruthú a tógadh ar Hugo. Is gineadóir ábhar statach é Hugo.

Dóibh siúd nach bhfuil eolach ar ghineadóirí statacha, inseoidh mé beagán eile duit fúthu. Murab ionann agus gnáth-innill láithreáin ghréasáin le bunachar sonraí agus roinnt PHP, a ghineann leathanaigh ar an eitilt, nuair a iarrann úsáideoir é, déantar gineadóirí statacha a dhearadh beagán difriúil. Ligeann siad duit foinsí a ghlacadh, de ghnáth sraith de chomhaid i marcáil Markdown agus teimpléid téama, ansin iad a thiomsú isteach i suíomh Gréasáin iomlán críochnaithe.

Is é sin, mar thoradh air sin, gheobhaidh tú struchtúr eolaire agus sraith de chomhaid HTML a ghintear, ar féidir leat a uaslódáil go simplí chuig aon óstáil saor agus láithreán gréasáin oibre a fháil.

Is féidir leat Hugo a shuiteáil go háitiúil agus triail a bhaint as:

Suíomh nua á thosú:

hugo new site docs.example.org

Agus ag an am céanna an stór git:

cd docs.example.org
git init

Go dtí seo, tá ár suíomh gan staonadh agus le go mbeidh rud éigin le feiceáil air, ní mór dúinn ar dtús téama a nascadh; níl i dtéama ach sraith de theimpléid agus rialacha sonraithe trína ngintear ár suíomh.

Don téama a úsáidfimid Foghlaim, atá, i mo thuairim, oiriúnach go foirfe le haghaidh láithreán doiciméadúcháin.

Ba mhaith liom aird ar leith a thabhairt ar an bhfíric nach gá dúinn na comhaid téama a shábháil inár stór tionscadail; ina ionad sin, is féidir linn é a nascadh go simplí trí úsáid a bhaint as fomhodúl git:

git submodule add https://github.com/matcornic/hugo-theme-learn themes/learn

Mar sin, ní bheidh inár stór ach comhaid a bhaineann go díreach lenár dtionscadal, agus fanfaidh an téama nasctha mar nasc le stór sonrach agus gealltanas ann, is é sin, is féidir é a tharraingt ón mbunfhoinse i gcónaí agus ná bíodh eagla ort. athruithe neamh-chomhoiriúnacha.

A ligean ar cheartú an config cumraíochta.toml:

baseURL = "http://docs.example.org/"
languageCode = "en-us"
title = "My Docs Site"
theme = "learn"

Cheana féin ag an gcéim seo is féidir leat:

hugo server

Agus ag an seoladh http://localhost:1313/ seiceáil ar ár suíomh Gréasáin nuachruthaithe, déanann gach athrú a dhéantar ar an eolaire an leathanach oscailte sa bhrabhsálaí a nuashonrú go huathoibríoch, an-áisiúil!

Déanaimis iarracht leathanach clúdaigh a chruthú i ábhar/_innéacs.md:

# My docs site

## Welcome to the docs!

You will be very smart :-)

Gabháil scáileáin den leathanach nuachruthaithe

Chun suíomh a ghiniúint, níl le déanamh ach rith:

hugo

Ábhar eolaire poiblí/ agus beidh do shuíomh Gréasáin.
Sea, dála an scéil, cuirimis láithreach é .gitnore:

echo /public > .gitignore

Ná déan dearmad ár n-athruithe a dhéanamh:

git add .
git commit -m "New site created"

2. Ullmhú an Dockerfile

Tá sé in am againn struchtúr ár stór a shainiú. De ghnáth bainim úsáid as rud éigin mar:

.
├── deploy
│   ├── app1
│   └── app2
└── dockerfiles
    ├── image1
    └── image2

• comhaid docker/ — beidh eolairí ann le Dockerfiles agus gach rud atá riachtanach chun ár n-íomhánna Docker a thógáil.
• imscaradh/ — tá eolairí ann chun ár bhfeidhmchláir a imscaradh chuig Kubernetes

Mar sin, cruthóimid ár gcéad Dockerfile feadh an chosáin comhaid docker / láithreán gréasáin / Dockerfile

FROM alpine:3.11 as builder
ARG HUGO_VERSION=0.62.0
RUN wget -O- https://github.com/gohugoio/hugo/releases/download/v${HUGO_VERSION}/hugo_${HUGO_VERSION}_linux-64bit.tar.gz | tar -xz -C /usr/local/bin
ADD . /src
RUN hugo -s /src

FROM alpine:3.11
RUN apk add --no-cache darkhttpd
COPY --from=builder /src/public /var/www
ENTRYPOINT [ "/usr/bin/darkhttpd" ]
CMD [ "/var/www" ]

Mar a fheiceann tú, tá dhá cheann sa Dockerfile Ó, tugtar an deis seo tógáil ilchéime agus ligeann duit gach rud nach bhfuil gá leis a eisiamh ón íomhá docker deiridh.
Mar sin, ní bheidh san íomhá deiridh ach amháin dorchahttpd (freastalaí HTTP éadrom) agus poiblí/ — ábhar ár suíomh Gréasáin arna ghiniúint go statach.

Ná déan dearmad ár n-athruithe a dhéanamh:

git add dockerfiles/website
git commit -m "Add Dockerfile for website"

3. Ag cur aithne ar kaniko

Mar thógálaí íomhá docker, chinn mé úsáid a bhaint as cailiocht, ós rud é nach bhfuil deamhan docker ag teastáil lena oibriú, agus is féidir an tógáil féin a dhéanamh ar aon mheaisín agus is féidir an taisce a stóráil go díreach sa chlár, rud a chuirfeadh deireadh leis an ngá atá le stóráil leanúnach lán-chuimsitheach.

Chun an íomhá a thógáil, ach reáchtáil an coimeádán le seiceadóir kaniko agus tabhair an comhthéacs tógála reatha dó; is féidir é seo a dhéanamh go háitiúil freisin, tríd an docker:

docker run -ti --rm 
  -v $PWD:/workspace 
  -v ~/.docker/config.json:/kaniko/.docker/config.json:ro 
  gcr.io/kaniko-project/executor:v0.15.0 
  --cache 
  --dockerfile=dockerfiles/website/Dockerfile 
  --destination=registry.gitlab.com/kvaps/docs.example.org/website:v0.0.1

Cá háit registry.gitlab.com/kvaps/docs.example.org/website - ainm do íomhá docker; tar éis tógáil, seolfar go huathoibríoch isteach sa chlár docker é.

Paraiméadar --taisce ligeann sé duit sraitheanna a thaisceadh sa chlár docker; mar shampla, déanfar iad a shábháil i registry.gitlab.com/kvaps/docs.example.org/website/cache, ach is féidir leat cosán eile a shonrú ag baint úsáide as an bparaiméadar --taisce-repo.

Gabháil scáileáin den docker-registry

4. Ag cur aithne ar qbec

Qbec Is uirlis imlonnaithe é a ligeann duit cur síos dearbhach a dhéanamh ar d’fheidhmchláir agus iad a imscaradh chuig Kubernetes. Trí úsáid a bhaint as Jsonnet mar phríomh-chomhréir is féidir leat an cur síos ar dhifríochtaí trasna timpeallachtaí iolracha a shimpliú go mór, agus freisin cuireann sé deireadh le athrá cód beagnach go hiomlán.

Is féidir é seo a bheith fíor go háirithe i gcásanna nuair is gá duit feidhmchlár a imscaradh chuig roinnt braislí le paraiméadair éagsúla agus gur mhaith leat cur síos dearbhach a dhéanamh orthu in Git.

Ligeann Qbec duit freisin cairteacha Helm a sholáthar trí na paraiméadair riachtanacha a rith agus ansin iad a oibriú ar an mbealach céanna le manifests rialta, lena n-áirítear is féidir leat sócháin éagsúla a chur i bhfeidhm orthu, agus ligeann sé seo, ar a seal, duit fáil réidh leis an ngá atá le úsáid ChartMuseum. Is é sin, is féidir leat cairteacha a stóráil agus a sholáthar go díreach ó git, áit a mbaineann siad.

Mar a dúirt mé níos luaithe, stórálfaimid gach imscaradh in eolaire imscaradh/:

mkdir deploy
cd deploy

Cuirimis ár gcéad iarratas i dtosach:

qbec init website
cd website

Anois tá cuma mar seo ar struchtúr ár bhfeidhmchláir:

.
├── components
├── environments
│   ├── base.libsonnet
│   └── default.libsonnet
├── params.libsonnet
└── qbec.yaml

a ligean ar breathnú ar an gcomhad qbec.yaml:

apiVersion: qbec.io/v1alpha1
kind: App
metadata:
  name: website
spec:
  environments:
    default:
      defaultNamespace: docs
      server: https://kubernetes.example.org:8443
  vars: {}

Anseo tá suim againn go príomha timpeallacht, Tá timpeallacht réamhshocraithe cruthaithe ag qbec cheana féin dúinn agus ghlac sé an seoladh freastalaí, chomh maith le spás ainm ónár kubeconfig reatha.
Anois nuair a imscaradh go réamhshocraithe timpeallacht, ní imlonnóidh qbec i gcónaí ach chuig an mbraisle Kubernetes sonraithe agus chuig an ainmspás sonraithe, is é sin, ní gá duit aistriú idir comhthéacsanna agus spásanna ainm chun imscaradh a dhéanamh a thuilleadh.
Más gá, is féidir leat na socruithe sa chomhad seo a nuashonrú i gcónaí.

Déantar cur síos ar do thimpeallachtaí go léir i qbec.yaml, agus sa chomhad params.libsonnet, áit a ndeir sé cá háit a bhfaighidh sé na paraiméadair dóibh.

Ansin feicimid dhá eolaire:

• comhpháirteanna/ — déanfar gach léiriú dár bhfeidhmchlár a stóráil anseo; is féidir cur síos a dhéanamh orthu i gcomhaid jsonnet agus i gcomhaid rialta yaml
• timpeallachtaí/ — anseo déanfaimid cur síos ar na hathróga (paraiméadair) go léir dár dtimpeallachtaí.

De réir réamhshocraithe tá dhá chomhad againn:

• timpeallachtaí/base.libsonnet - beidh paraiméadair choiteanna ann do gach timpeallacht
• timpeallachtaí/default.libsonnet — ina bhfuil paraiméadair sáraithe don chomhshaol réamhshocraithe

a ligean ar oscailt timpeallachtaí/base.libsonnet agus cuir paraiméadair dár gcéad chomhpháirt ann:

{
  components: {
    website: {
      name: 'example-docs',
      image: 'registry.gitlab.com/kvaps/docs.example.org/website:v0.0.1',
      replicas: 1,
      containerPort: 80,
      servicePort: 80,
      nodeSelector: {},
      tolerations: [],
      ingressClass: 'nginx',
      domain: 'docs.example.org',
    },
  },
}

Déanaimis ár gcéad chomhpháirt a chruthú freisin comhpháirteanna/láithreán gréasáin.jsonnet:

local env = {
  name: std.extVar('qbec.io/env'),
  namespace: std.extVar('qbec.io/defaultNs'),
};
local p = import '../params.libsonnet';
local params = p.components.website;

[
  {
    apiVersion: 'apps/v1',
    kind: 'Deployment',
    metadata: {
      labels: { app: params.name },
      name: params.name,
    },
    spec: {
      replicas: params.replicas,
      selector: {
        matchLabels: {
          app: params.name,
        },
      },
      template: {
        metadata: {
          labels: { app: params.name },
        },
        spec: {
          containers: [
            {
              name: 'darkhttpd',
              image: params.image,
              ports: [
                {
                  containerPort: params.containerPort,
                },
              ],
            },
          ],
          nodeSelector: params.nodeSelector,
          tolerations: params.tolerations,
          imagePullSecrets: [{ name: 'regsecret' }],
        },
      },
    },
  },
  {
    apiVersion: 'v1',
    kind: 'Service',
    metadata: {
      labels: { app: params.name },
      name: params.name,
    },
    spec: {
      selector: {
        app: params.name,
      },
      ports: [
        {
          port: params.servicePort,
          targetPort: params.containerPort,
        },
      ],
    },
  },
  {
    apiVersion: 'extensions/v1beta1',
    kind: 'Ingress',
    metadata: {
      annotations: {
        'kubernetes.io/ingress.class': params.ingressClass,
      },
      labels: { app: params.name },
      name: params.name,
    },
    spec: {
      rules: [
        {
          host: params.domain,
          http: {
            paths: [
              {
                backend: {
                  serviceName: params.name,
                  servicePort: params.servicePort,
                },
              },
            ],
          },
        },
      ],
    },
  },
]

Sa chomhad seo rinneamar cur síos ar thrí aonán Kubernetes láithreach, is iad seo: imscaradh, seirbhís и Ingress. Más mian linn, d'fhéadfaimis iad a chur i gcomhpháirteanna éagsúla, ach ag an gcéim seo beidh ceann amháin go leor dúinn.

error jsonnet an-chosúil le json rialta, i bprionsabal, tá json rialta bailí cheana féin jsonnet, mar sin ar dtús d'fhéadfadh sé a bheith níos éasca duit úsáid a bhaint as seirbhísí ar líne mar aml2son chun do ghnáth yaml a thiontú ina json, nó, mura bhfuil aon athróg i do chomhpháirteanna, is féidir cur síos a dhéanamh orthu i bhfoirm yaml rialta.

Agus iad ag obair le jsonnet Molaim go mór breiseán a shuiteáil do d'eagarthóir

Mar shampla, tá breiseán le haghaidh vim vim-jsonnet, a chuireann béim ar chomhréir ar siúl agus a fhorghníomhaíonn go huathoibríoch jsonnet fmt gach uair a shábhálann tú (tá jsonnet suiteáilte).

Tá gach rud réidh, anois is féidir linn tosú ag imscaradh:

Chun féachaint cad a fuair muid, a ligean ar siúl:

qbec show default

Ag an aschur, feicfidh tú manifests yaml rindreáilte a chuirfear i bhfeidhm ar an mbraisle réamhshocraithe.

Go hiontach, cuir i bhfeidhm anois:

qbec apply default

Ag an aschur feicfidh tú i gcónaí cad a dhéanfar i do bhraisle, iarrfaidh qbec ort aontú leis na hathruithe trí chlóscríobh y beidh tú in ann do rún a dhearbhú.

Tá ár n-iarratas réidh agus imscaradh!

Má dhéanann tú athruithe, is féidir leat i gcónaí:

qbec diff default

féachaint conas a rachaidh na hathruithe seo i bhfeidhm ar an imscaradh reatha

Ná déan dearmad ár n-athruithe a dhéanamh:

cd ../..
git add deploy/website
git commit -m "Add deploy for website"

5. Ag iarraidh Gitlab-rádala le Kubernetes-seiceadóir

Go dtí le déanaí níor úsáid mé ach rialta gitlab-rádala ar mheaisín réamhullmhaithe (coimeádán LXC) le sliogán nó docker-seiceadóir. Ar dtús, bhí roinnt reathaithe den sórt sin sainmhínithe go domhanda inár gitlab. Bhailigh siad íomhánna docker do gach tionscadal.

Ach mar a léirigh cleachtas, níl an rogha seo an chuid is mó idéalach, i dtéarmaí praiticiúlacht agus sábháilteachta. Tá sé i bhfad níos fearr agus níos cearta ó thaobh idé-eolaíochta de go n-imscarfar reathaithe ar leith do gach tionscadal, nó fiú do gach timpeallacht.

Go fortunately, ní fadhb é seo ar chor ar bith, ós rud é anois déanfaimid imscaradh gitlab-rádala go díreach mar chuid dár dtionscadal ceart i Kubernetes.

Soláthraíonn Gitlab cairt stiúrtha réamhdhéanta chun an rádala gitlab a imscaradh go Kubernetes. Mar sin níl le déanamh ach a fháil amach comhartha cláraithe le haghaidh ár dtionscadal i Socruithe -> CI / CD -> Runners agus cuir ar aghaidh é:

helm repo add gitlab https://charts.gitlab.io

helm install gitlab-runner 
  --set gitlabUrl=https://gitlab.com 
  --set runnerRegistrationToken=yga8y-jdCusVDn_t4Wxc 
  --set rbac.create=true 
  gitlab/gitlab-runner

I gcás:

• https://gitlab.com — seoladh do fhreastalaí Gitlab.
• yga8y-jdCusVDn_t4Wxc — comhartha clárúcháin do thionscadal.
• rbac.create=fíor — soláthraíonn sé an méid is gá de phribhléidí don rádala chun go mbeidh sé in ann pods a chruthú chun ár dtascanna a chomhlíonadh ag baint úsáide as kubernetes-seiceadóir.

Má dhéantar gach rud i gceart, ba cheart duit rádala cláraithe a fheiceáil sa rannóg Runners, i socruithe do thionscadail.

Gabháil scáileáin den reathaí breise

An bhfuil sé chomh simplí sin? - Sea, tá sé chomh simplí sin! Ní mó stró ar bith le reathaithe a chlárú de láimh, as seo amach cruthófar agus scriosfar reathaithe go huathoibríoch.

6. Imscaradh cairteacha Helm le QBEC

Ós rud é shocraigh muid a mheas gitlab-rádala mar chuid dár dtionscadal, tá sé in am cur síos a dhéanamh air inár stór Git.

D’fhéadfaimis cur síos air mar chomhpháirt ar leith láithreán gréasáin, ach sa todhchaí tá sé beartaithe againn cóipeanna éagsúla a imscaradh láithreán gréasáin go minic, murab ionann agus gitlab-rádala, a imscarfar uair amháin in aghaidh an bhraisle Kubernetes. Mar sin déanaimis iarratas ar leith a thosú air:

cd deploy
qbec init gitlab-runner
cd gitlab-runner

An uair seo ní chuirfimid síos ar eintitis Kubernetes de láimh, ach tógfaimid cairt Helm réidh-déanta. Ceann de na buntáistí a bhaineann le qbec is ea an cumas cairteacha Helm a sholáthar go díreach ó stór Git.

Déanaimis é a nascadh le fomhodúl git:

git submodule add https://gitlab.com/gitlab-org/charts/gitlab-runner vendor/gitlab-runner

Anois an t-eolaire díoltóir/gitlab-runner Tá stór againn le cairt do gitlab-runner.

Ar an mbealach céanna, is féidir leat stórtha eile a nascadh, mar shampla, an stór iomlán le cairteacha oifigiúla https://github.com/helm/charts

Déanaimis cur síos ar an gcomhpháirt comhpháirteanna/gitlab-runner.jsonnet:

local env = {
  name: std.extVar('qbec.io/env'),
  namespace: std.extVar('qbec.io/defaultNs'),
};
local p = import '../params.libsonnet';
local params = p.components.gitlabRunner;

std.native('expandHelmTemplate')(
  '../vendor/gitlab-runner',
  params.values,
  {
    nameTemplate: params.name,
    namespace: env.namespace,
    thisFile: std.thisFile,
    verbose: true,
  }
)

An chéad argóint a expandHelmTemplate Gabhaimid an cosán go dtí an chairt, ansin params.values, a thógaimid ó pharaiméadair an chomhshaoil, ansin tagann an réad leis

• ainmTeimpléad — teideal eisithe
• ainmneacha — ainmspás aistrithe chuig an stiúradh
• an Comhad seo — paraiméadar riachtanach a théann an cosán chuig an gcomhad reatha
• briathra - Léiríonn an t-ordú teimpléad stiúrtha leis na hargóintí go léir agus an chairt á rindreáil

Anois déanaimis cur síos ar na paraiméadair dár gcomhpháirt i timpeallachtaí/base.libsonnet:

local secrets = import '../secrets/base.libsonnet';

{
  components: {
    gitlabRunner: {
      name: 'gitlab-runner',
      values: {
        gitlabUrl: 'https://gitlab.com/',
        rbac: {
          create: true,
        },
        runnerRegistrationToken: secrets.runnerRegistrationToken,
      },
    },
  },
}

Tabhair aird rádalaRegistrationToken glacaimid ó chomhad seachtrach rúin/base.libsonnet, déanaimis é a chruthú:

{
  runnerRegistrationToken: 'yga8y-jdCusVDn_t4Wxc',
}

Déanaimis seiceáil an n-oibríonn gach rud:

qbec show default

má tá gach rud in ord, ansin is féidir linn ár scaoileadh a imlonnaíodh roimhe seo a scriosadh trí Helm:

helm uninstall gitlab-runner

agus imscaradh mar an gcéanna é, ach trí qbec:

qbec apply default

7. Réamhrá ar git-crypt

Git-crypt Is uirlis é a ligeann duit criptiú trédhearcach a shocrú do do stór.

Faoi láthair, is é seo an chuma atá ar ár struchtúr eolaire le haghaidh gitlab-runner:

.
├── components
│   ├── gitlab-runner.jsonnet
├── environments
│   ├── base.libsonnet
│   └── default.libsonnet
├── params.libsonnet
├── qbec.yaml
├── secrets
│   └── base.libsonnet
└── vendor
    └── gitlab-runner (submodule)

Ach níl sé sábháilte rúin a stóráil in Git, an ea? Mar sin ní mór dúinn iad a chriptiú i gceart.

De ghnáth, ar mhaithe le hathróg amháin, ní dhéanann sé seo ciall i gcónaí. Is féidir leat rúin a aistriú chuig qbec agus trí athróga comhshaoil ​​do chórais CI.
Ach is fiú a thabhairt faoi deara go bhfuil tionscadail níos casta ann freisin a bhféadfadh go leor rúin eile a bheith iontu; beidh sé thar a bheith deacair iad go léir a aistriú trí athróga comhshaoil.

Thairis sin, sa chás seo ní ba mhaith liom a bheith in ann a insint duit faoi a leithéid de uirlis iontach mar git-crypt.

git-crypt Tá sé áisiúil freisin sa mhéid is go gceadaíonn sé duit stair iomlán na rúin a shábháil, chomh maith le coinbhleachtaí a chur i gcomparáid, a chumasc agus a réiteach ar an mbealach céanna a bhfuil taithí againn orthu i gcás Git.

An chéad rud tar éis a shuiteáil git-crypt caithfimid eochracha a ghiniúint dár stór:

git crypt init

Má tá eochair PGP agat, is féidir leat tú féin a chur isteach láithreach mar chomhoibrí don tionscadal seo:

git-crypt add-gpg-user [email protected]

Ar an mbealach seo is féidir leat an stór seo a dhíchriptiú i gcónaí le d'eochair phríobháideach.

Mura bhfuil eochair PGP agat agus mura bhfuil tú ag súil leis, is féidir leat dul an bealach eile agus eochair an tionscadail a easpórtáil:

git crypt export-key /path/to/keyfile

Dá bhrí sin, aon duine a bhfuil onnmhairiú eochairchomhad beidh siad in ann do stór a dhíchriptiú.

Tá sé in am ár gcéad rún a chur ar bun.
Lig dom a mheabhrú duit go bhfuil muid fós san eolaire imscaradh/gitlab-runner/, áit a bhfuil eolaire againn rúin/, a ligean ar a chriptiú na comhaid go léir ann, le haghaidh seo beidh muid a chruthú comhad rúin/.gitattributes leis an ábhar seo a leanas:

* filter=git-crypt diff=git-crypt
.gitattributes !filter !diff

Mar atá le feiceáil ón ábhar, tá gach comhad folaithe * a thiomáint tríd git-crypt, ach amháin an chuid is mó .gitaitribh

Is féidir linn é seo a sheiceáil trí:

git crypt status -e

Is éard a bheidh san aschur ná liosta de na comhaid go léir sa stór a bhfuil criptiú cumasaithe ina leith

Sin uile, anois is féidir linn ár n-athruithe a ghealladh go sábháilte:

cd ../..
git add .
git commit -m "Add deploy for gitlab-runner"

Chun stór a bhlocáil, rith:

git crypt lock

agus láithreach beidh gach comhad criptithe a iompú isteach i rud éigin dénártha, beidh sé dodhéanta iad a léamh.
Chun an stór a dhíchriptiú, rith:

git crypt unlock

8. Cruthaigh íomhá bosca uirlisí

Is íomhá é íomhá bosca uirlisí leis na huirlisí go léir a úsáidfimid chun ár dtionscadal a imscaradh. Bainfidh an reathaí Gitlab úsáid as chun gnáththascanna imlonnaithe a dhéanamh.

Tá gach rud simplí anseo, déanaimis ceann nua a chruthú comhaid docker/bosca uirlisí/Dockerfile leis an ábhar seo a leanas:

FROM alpine:3.11

RUN apk add --no-cache git git-crypt

RUN QBEC_VER=0.10.3 
 && wget -O- https://github.com/splunk/qbec/releases/download/v${QBEC_VER}/qbec-linux-amd64.tar.gz 
     | tar -C /tmp -xzf - 
 && mv /tmp/qbec /tmp/jsonnet-qbec /usr/local/bin/

RUN KUBECTL_VER=1.17.0 
 && wget -O /usr/local/bin/kubectl 
      https://storage.googleapis.com/kubernetes-release/release/v${KUBECTL_VER}/bin/linux/amd64/kubectl 
 && chmod +x /usr/local/bin/kubectl

RUN HELM_VER=3.0.2 
 && wget -O- https://get.helm.sh/helm-v${HELM_VER}-linux-amd64.tar.gz 
     | tar -C /tmp -zxf - 
 && mv /tmp/linux-amd64/helm /usr/local/bin/helm

Mar a fheiceann tú, san íomhá seo suiteálaimid na fóntais go léir a d’úsáideamar chun ár bhfeidhmchlár a imscaradh. Níl sé ag teastáil uainn anseo mura rud é cubectl, ach b'fhéidir gur mhaith leat imirt timpeall leis le linn na céime socraithe píblíne.

Chomh maith leis sin, le go mbeimid in ann cumarsáid a dhéanamh le Kubernetes agus imscaradh chuige, ní mór dúinn ról a chumrú do na pods a ghineann gitlab-runner.

Chun seo a dhéanamh, a ligean ar dul chuig an eolaire le gitlab-runner:

cd deploy/gitlab-runner

agus cuir comhpháirt nua leis comhpháirteanna/rbac.jsonnet:

local env = {
  name: std.extVar('qbec.io/env'),
  namespace: std.extVar('qbec.io/defaultNs'),
};
local p = import '../params.libsonnet';
local params = p.components.rbac;

[
  {
    apiVersion: 'v1',
    kind: 'ServiceAccount',
    metadata: {
      labels: {
        app: params.name,
      },
      name: params.name,
    },
  },
  {
    apiVersion: 'rbac.authorization.k8s.io/v1',
    kind: 'Role',
    metadata: {
      labels: {
        app: params.name,
      },
      name: params.name,
    },
    rules: [
      {
        apiGroups: [
          '*',
        ],
        resources: [
          '*',
        ],
        verbs: [
          '*',
        ],
      },
    ],
  },
  {
    apiVersion: 'rbac.authorization.k8s.io/v1',
    kind: 'RoleBinding',
    metadata: {
      labels: {
        app: params.name,
      },
      name: params.name,
    },
    roleRef: {
      apiGroup: 'rbac.authorization.k8s.io',
      kind: 'Role',
      name: params.name,
    },
    subjects: [
      {
        kind: 'ServiceAccount',
        name: params.name,
        namespace: env.namespace,
      },
    ],
  },
]

Déanfaimid cur síos freisin ar na paraiméadair nua i timpeallachtaí/base.libsonnet, a bhreathnaíonn mar seo anois:

local secrets = import '../secrets/base.libsonnet';

{
  components: {
    gitlabRunner: {
      name: 'gitlab-runner',
      values: {
        gitlabUrl: 'https://gitlab.com/',
        rbac: {
          create: true,
        },
        runnerRegistrationToken: secrets.runnerRegistrationToken,
        runners: {
          serviceAccountName: $.components.rbac.name,
          image: 'registry.gitlab.com/kvaps/docs.example.org/toolbox:v0.0.1',
        },
      },
    },
    rbac: {
      name: 'gitlab-runner-deploy',
    },
  },
}

Tabhair aird $.components.rbac.ainm Tagraíonn ainm don chomhpháirt rbac

Déanaimis seiceáil ar a bhfuil athrú:

qbec diff default

agus cuir ár n-athruithe i bhfeidhm ar Kubernetes:

qbec apply default

Chomh maith leis sin, ná déan dearmad ár n-athruithe a dhéanamh ar git:

cd ../..
git add dockerfiles/toolbox
git commit -m "Add Dockerfile for toolbox"
git add deploy/gitlab-runner
git commit -m "Configure gitlab-runner to use toolbox"

9. Ár gcéad phíblíne agus cóimeáil íomhánna ag clibeanna

Ag bun an tionscadail cruthóimid .gitlab-ci.yml leis an ábhar seo a leanas:

.build_docker_image:
  stage: build
  image:
    name: gcr.io/kaniko-project/executor:debug-v0.15.0
    entrypoint: [""]
  before_script:
    - echo "{"auths":{"$CI_REGISTRY":{"username":"$CI_REGISTRY_USER","password":"$CI_REGISTRY_PASSWORD"}}}" > /kaniko/.docker/config.json

build_toolbox:
  extends: .build_docker_image
  script:
    - /kaniko/executor --cache --context $CI_PROJECT_DIR/dockerfiles/toolbox --dockerfile $CI_PROJECT_DIR/dockerfiles/toolbox/Dockerfile --destination $CI_REGISTRY_IMAGE/toolbox:$CI_COMMIT_TAG
  only:
    refs:
      - tags

build_website:
  extends: .build_docker_image
  variables:
    GIT_SUBMODULE_STRATEGY: normal
  script:
    - /kaniko/executor --cache --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/dockerfiles/website/Dockerfile --destination $CI_REGISTRY_IMAGE/website:$CI_COMMIT_TAG
  only:
    refs:
      - tags

Tabhair faoi deara go n-úsáidimid GIT_SUBMODULE_STRATEGY : gnáth do na poist sin inar gá duit fo-mhodúil a thúsú go sainráite roimh iad a fhorghníomhú.

Ná déan dearmad ár n-athruithe a dhéanamh:

git add .gitlab-ci.yml
git commit -m "Automate docker build"

I mo thuairimse, is féidir linn glaoch seo go sábháilte leagan v0.0.1 agus cuir an chlib leis:

git tag v0.0.1

Cuirfimid clibeanna leis aon uair is gá dúinn leagan nua a scaoileadh. Beidh clibeanna in íomhánna Docker ceangailte le clibeanna Git. Cuirfidh gach brú le clib nua tús le tógáil na n-íomhánna leis an gclib seo.

Lig dúinn é a dhéanamh git bhrú --clibeanna, agus breathaimis ar ár gcéad phíblíne:

Gabháil scáileáin den chéad phíblíne

Is fiú d'aird a tharraingt ar an bhfíric go bhfuil cóimeáil de réir clibeanna oiriúnach chun íomhánna docker a thógáil, ach nach bhfuil sé oiriúnach chun iarratas a imscaradh chuig Kubernetes. Ós rud é gur féidir clibeanna nua a shannadh do shean-gheallta, sa chás seo, cuirfear an seanleagan amach as an bpíblíne a thosú dóibh.

Chun an fhadhb seo a réiteach, de ghnáth bíonn tógáil íomhánna duga ceangailte le clibeanna, agus imscaradh an fheidhmchláir chuig brainse máistir, ina bhfuil leaganacha de na híomhánna bailithe le cód crua. Seo áit ar féidir leat aischéimniú a thosú le cúl simplí máistir-craobhacha.

10. Imscaradh a uathoibriú

Chun gur féidir le Gitlab-runner ár rúin a dhíchriptiú, beidh orainn an eochair stórtha a onnmhairiú agus é a chur lenár n-athróga timpeallachta CI:

git crypt export-key /tmp/docs-repo.key
base64 -w0 /tmp/docs-repo.key; echo

Sábhálfaimid an líne mar thoradh air in Gitlab; chun é seo a dhéanamh, déanaimis dul chuig ár socruithe tionscadail:
Socruithe -> CI / CD -> Athróga

Agus cruthaimis athróg nua:

cineál
Key
luach
cosanta
Masked
Raon feidhme

File
GITCRYPT_KEY
<your string>
true (le linn na hoiliúna is féidir leat false)
true
All environments

Gabháil scáileáin den athróg bhreise

Anois a ligean ar thabhairt cothrom le dáta ár .gitlab-ci.yml ag cur leis:

.deploy_qbec_app:
  stage: deploy
  only:
    refs:
      - master

deploy_gitlab_runner:
  extends: .deploy_qbec_app
  variables:
    GIT_SUBMODULE_STRATEGY: normal
  before_script:
    - base64 -d "$GITCRYPT_KEY" | git-crypt unlock -
  script:
    - qbec apply default --root deploy/gitlab-runner --force:k8s-context __incluster__ --wait --yes

deploy_website:
  extends: .deploy_qbec_app
  script:
    - qbec apply default --root deploy/website --force:k8s-context __incluster__ --wait --yes

Anseo tá roinnt roghanna nua cumasaithe againn le haghaidh qbec:

• -- root roinnt / app — ligeann sé duit eolaire feidhmchlár ar leith a chinneadh
• --force:k8s-comhthéacs __cluster__ - athróg draíochta é seo a deir go dtarlóidh an t-imscaradh sa bhraisle chéanna ina bhfuil gtilab-runner ag rith. Tá sé seo riachtanach mar ar shlí eile déanfaidh qbec iarracht freastalaí Kubernetes oiriúnach a aimsiú i do kubeconfig
• --fan — cuireann sé iallach ar qbec fanacht go dtí go dtéann na hacmhainní a chruthaíonn sé isteach sa stát Réidh agus go dtí go n-imíonn siad ansin le cód scoir rathúil.
• —tá - go simplí díchumasaítear an bhlaosc idirghníomhach An bhfuil tú cinnte? nuair a imscartar.

Ná déan dearmad ár n-athruithe a dhéanamh:

git add .gitlab-ci.yml
git commit -m "Automate deploy"

Agus tar éis bhrú git feicfimid conas a úsáideadh ár n-iarratas:

Gabháil scáileáin den dara píblíne

11. Déantáin agus cóimeáil agus iad ag brú chun máistreachta

De ghnáth, is leor na céimeanna a thuairiscítear thuas chun beagnach aon mhicrisheirbhís a thógáil agus a sheachadadh, ach nílimid ag iarraidh clib a chur leis gach uair a chaithfimid an suíomh a nuashonrú. Mar sin, déanfaimid bealach níos dinimiciúla agus cuirfimid imscaradh díolama ar bun sa mháistir-bhrainse.

Is é an smaoineamh simplí: anois an íomhá ar ár láithreán gréasáin Beidh atógáil gach uair a bhrú tú isteach máistir, agus ansin imscaradh go huathoibríoch chuig Kubernetes.

Déanaimis an dá phost seo a nuashonrú inár .gitlab-ci.yml:

build_website:
  extends: .build_docker_image
  variables:
    GIT_SUBMODULE_STRATEGY: normal
  script:
    - mkdir -p $CI_PROJECT_DIR/artifacts
    - /kaniko/executor --cache --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/dockerfiles/website/Dockerfile --destination $CI_REGISTRY_IMAGE/website:$CI_COMMIT_REF_NAME --digest-file $CI_PROJECT_DIR/artifacts/website.digest
  artifacts:
    paths:
      - artifacts/
  only:
    refs:
      - master
      - tags

deploy_website:
  extends: .deploy_qbec_app
  script:
    - DIGEST="$(cat artifacts/website.digest)"
    - qbec apply default --root deploy/website --force:k8s-context __incluster__ --wait --yes --vm:ext-str digest="$DIGEST"

Tabhair faoi deara go bhfuil snáithe curtha leis againn máistir к tagairtí le haghaidh post láithreán gréasáin tógála_ agus úsáidimid anois $CI_COMMIT_REF_NAME in ionad $CI_COMMIT_TAG, is é sin, táimid gan ceangal ó chlibeanna i Git agus anois déanfaimid íomhá a bhrú le hainm an bhrainse tiomantais a chuir tús leis an bpíblíne. Is fiú a thabhairt faoi deara go n-oibreoidh sé seo le clibeanna freisin, a ligfidh dúinn pictiúir de shuíomh a shábháil le leagan sonrach sa chlár docker.

Nuair is féidir ainm an chlib docker le haghaidh leagan nua den láithreán a athrú, ní mór dúinn fós cur síos a dhéanamh ar na hathruithe ar Kubernetes, nó ní dhéanfaidh sé ach an feidhmchlár a ath-imscaradh ón íomhá nua, mar ní thabharfaidh sé faoi deara aon athruithe ar an íomhá léiriú imscaradh.

Rogha —vm:ext-str achoimre=”$DIGEST” le haghaidh qbec - ligeann sé duit athróg sheachtrach a chur ar aghaidh chuig jsonnet. Ba mhaith linn é a ath-imscaradh sa bhraisle le gach eisiúint dár n-iarratas. Ní féidir linn an t-ainm clib a úsáid a thuilleadh, rud nach féidir a athrú anois, mar ní mór dúinn a bheith ceangailte le leagan sonrach den íomhá agus an t-imscaradh a spreagadh nuair a athraíonn sé.

Anseo gheobhaidh muid cúnamh ó chumas Kaniko íomhá díolama a shábháil i gcomhad (rogha --digest-comhad)
Ansin aistreoimid an comhad seo agus léifimid é tráth an imscartha.

Déanaimis nuashonrú ar na paraiméadair dár imscaradh/suíomh gréasáin/environments/base.libsonnet a bheidh cuma mar seo anois:

{
  components: {
    website: {
      name: 'example-docs',
      image: 'registry.gitlab.com/kvaps/docs.example.org/website@' + std.extVar('digest'),
      replicas: 1,
      containerPort: 80,
      servicePort: 80,
      nodeSelector: {},
      tolerations: [],
      ingressClass: 'nginx',
      domain: 'docs.example.org',
    },
  },
}

Déanta, anois aon tiomantas isteach máistir tús le tógáil an íomhá docker do láithreán gréasáin, agus ansin é a imscaradh chuig Kubernetes.

Ná déan dearmad ár n-athruithe a dhéanamh:

git add .
git commit -m "Configure dynamic build"

Déanfaimid seiceáil níos déanaí bhrú git ba cheart dúinn rud mar seo a fheiceáil:

Seat den phíblíne don mháistir

I bprionsabal, ní gá dúinn gitlab-runner a ath-imscaradh le gach brú, mura rud é, ar ndóigh, nach bhfuil aon athrú ar a chumraíocht, déanaimis é a shocrú i .gitlab-ci.yml:

deploy_gitlab_runner:
  extends: .deploy_qbec_app
  variables:
    GIT_SUBMODULE_STRATEGY: normal
  before_script:
    - base64 -d "$GITCRYPT_KEY" | git-crypt unlock -
  script:
    - qbec apply default --root deploy/gitlab-runner --force:k8s-context __incluster__ --wait --yes
  only:
    changes:
      - deploy/gitlab-runner/**/*

athruithe ligfidh tú chun monatóireacht a dhéanamh ar athruithe i imscaradh/gitlab-runner/ agus ní chuirfidh sé tús lenár bpost ach amháin má tá aon cheann ann

Ná déan dearmad ár n-athruithe a dhéanamh:

git add .gitlab-ci.yml
git commit -m "Reduce gitlab-runner deploy"

bhrú git, sin níos fearr:

Gabháil scáileáin den phíblíne nuashonraithe

12. Timpeallachtaí dinimiciúla

Tá sé in am againn ár bpíblíne a éagsúlú le timpeallachtaí dinimiciúla.

Ar dtús, déanaimis an post a nuashonrú láithreán gréasáin tógála_ inár .gitlab-ci.yml, an bloc a bhaint uaidh ach, a chuirfidh iallach ar Gitlab é a spreagadh ar aon ghealltanas chuig aon bhrainse:

build_website:
  extends: .build_docker_image
  variables:
    GIT_SUBMODULE_STRATEGY: normal
  script:
    - mkdir -p $CI_PROJECT_DIR/artifacts
    - /kaniko/executor --cache --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/dockerfiles/website/Dockerfile --destination $CI_REGISTRY_IMAGE/website:$CI_COMMIT_REF_NAME --digest-file $CI_PROJECT_DIR/artifacts/website.digest
  artifacts:
    paths:
      - artifacts/

Ansin nuashonraigh an post láithreán gréasáin imscaradh, cuir bloc ann timpeallacht:

deploy_website:
  extends: .deploy_qbec_app
  environment:
    name: prod
    url: https://docs.example.org
  script:
    - DIGEST="$(cat artifacts/website.digest)"
    - qbec apply default --root deploy/website --force:k8s-context __incluster__ --wait --yes --vm:ext-str digest="$DIGEST"

Tabharfaidh sé seo deis do Gitlab an post a chomhlachú leis táirge timpeallacht agus taispeáin an nasc ceart dó.

Anois cuirimis dhá phost eile leis:

deploy_website:
  extends: .deploy_qbec_app
  environment:
    name: prod
    url: https://docs.example.org
  script:
    - DIGEST="$(cat artifacts/website.digest)"
    - qbec apply default --root deploy/website --force:k8s-context __incluster__ --wait --yes --vm:ext-str digest="$DIGEST"

deploy_review:
  extends: .deploy_qbec_app
  environment:
    name: review/$CI_COMMIT_REF_NAME
    url: http://$CI_ENVIRONMENT_SLUG.docs.example.org
    on_stop: stop_review
  script:
    - DIGEST="$(cat artifacts/website.digest)"
    - qbec apply review --root deploy/website --force:k8s-context __incluster__ --wait --yes --vm:ext-str digest="$DIGEST" --vm:ext-str subdomain="$CI_ENVIRONMENT_SLUG" --app-tag "$CI_ENVIRONMENT_SLUG"
  only:
    refs:
    - branches
  except:
    refs:
      - master

stop_review:
  extends: .deploy_qbec_app
  environment:
    name: review/$CI_COMMIT_REF_NAME
    action: stop
  stage: deploy
  before_script:
    - git clone "$CI_REPOSITORY_URL" master
    - cd master
  script:
    - qbec delete review --root deploy/website --force:k8s-context __incluster__ --yes --vm:ext-str digest="$DIGEST" --vm:ext-str subdomain="$CI_ENVIRONMENT_SLUG" --app-tag "$CI_ENVIRONMENT_SLUG"
  variables:
    GIT_STRATEGY: none
  only:
    refs:
    - branches
  except:
    refs:
      - master
  when: manual

Seolfar iad nuair a bhrúitear iad chuig aon bhrainse seachas an máistir agus imscarfar an leagan réamhamhairc den suíomh.

Feicimid rogha nua do qbec: --app-tag — ligeann sé duit leaganacha imlonnaithe den fheidhmchlár a chlibeáil agus oibriú laistigh den chlib seo amháin; agus acmhainní á gcruthú agus á scriosadh i Kubernetes, ní oibreoidh qbec leo ach amháin.
Ar an mbealach seo ní féidir linn timpeallacht ar leith a chruthú do gach athbhreithniú, ach an ceann céanna a athúsáid.

Anseo úsáidimid freisin qbec iarratas a athbhreithniú, in ionad qbec iarratas réamhshocraithe - is é seo go díreach an tráth a ndéanfaimid iarracht cur síos a dhéanamh ar na difríochtaí dár dtimpeallachtaí (athbhreithniú agus réamhshocrú):

Cuirimis athbhreithniú a dhéanamh ar timpeallacht i imscaradh/suíomh gréasáin/qbec.yaml

spec:
  environments:
    review:
      defaultNamespace: docs
      server: https://kubernetes.example.org:8443

Ansin dearbhóimid é i imscaradh/suíomh gréasáin/params.libsonnet:

local env = std.extVar('qbec.io/env');
local paramsMap = {
  _: import './environments/base.libsonnet',
  default: import './environments/default.libsonnet',
  review: import './environments/review.libsonnet',
};

if std.objectHas(paramsMap, env) then paramsMap[env] else error 'environment ' + env + ' not defined in ' + std.thisFile

Agus scríobh síos na paraiméadair saincheaptha dó i imscaradh/suíomh gréasáin/environments/review.libsonnet:

// this file has the param overrides for the default environment
local base = import './base.libsonnet';
local slug = std.extVar('qbec.io/tag');
local subdomain = std.extVar('subdomain');

base {
  components+: {
    website+: {
      name: 'example-docs-' + slug,
      domain: subdomain + '.docs.example.org',
    },
  },
}

Breathnaímis freisin ar jobu stad_léirmheas, cuirfear i ngníomh é nuair a scriostar an brainse agus ionas nach ndéanann gitlab iarracht seiceáil amach a úsáidtear é GIT_STRATEGY: ceann ar bith, ina dhiaidh sin táimid ag Clón máistir-brainse agus scrios athbhreithniú tríd.
Tá sé rud beag mearbhall, ach níl bealach níos áille aimsithe agam fós.
Rogha eile is ea gach athbhreithniú a imscaradh chuig ainmspás óstáin, ar féidir a scartáil ina iomláine i gcónaí.

Ná déan dearmad ár n-athruithe a dhéanamh:

git add .
git commit -m "Enable automatic review"

bhrú git, git checkout -b tástála, tástáil tionscnaimh bhrú git, seiceáil:

Gabháil scáileáin de thimpeallachtaí cruthaithe i Gitlab

Tá gach rud ag obair? - iontach, scrios ár brainse tástála: máistir seiceála git, tionscnaimh bhrú git: tástáil, déanaimid seiceáil gur oibrigh na poist scriosadh timpeallachta gan earráidí.

Anseo ba mhaith liom a shoiléiriú láithreach gur féidir le haon fhorbróir i dtionscadal brainsí a chruthú, is féidir leis a athrú freisin .gitlab-ci.yml athróga rúnda a chomhdú agus a rochtain.
Dá bhrí sin, moltar go láidir a n-úsáid a cheadú ach amháin le haghaidh brainsí cosanta, mar shampla i máistir, nó cruthaigh sraith athróg ar leith do gach timpeallacht.

13. Apps Athbhreithnithe

Aipeanna Athbhreithnithe Is gné GitLab é seo a ligeann duit cnaipe a chur leis do gach comhad sa stór chun é a fheiceáil go tapa i dtimpeallacht imlonnaithe.

Chun go mbeidh na cnaipí seo le feiceáil, ní mór duit comhad a chruthú .gitlab/route-map.yml agus déan cur síos ar gach claochlú cosáin ann; inár gcás beidh sé an-simplí:

# Indices
- source: /content/(.+?)_index.(md|html)/ 
  public: '1'

# Pages
- source: /content/(.+?).(md|html)/ 
  public: '1/'

Ná déan dearmad ár n-athruithe a dhéanamh:

git add .gitlab/
git commit -m "Enable review apps"

bhrú git, agus seiceáil:

Gabháil scáileáin den chnaipe Review App

Tá jab déanta!

Foinsí tionscadail:

• ar Gitlab: https://gitlab.com/kvaps/docs.example.org
• ar GitHub: https://github.com/kvaps/docs.example.org

Go raibh maith agat as do aire, tá súil agam gur thaitin sé leat

Foinse: will.com