Halo! Anyar-anyar ieu, seueur alat automasi anu keren parantos dileupaskeun pikeun ngawangun gambar Docker sareng pikeun panyebaran ka Kubernetes. Dina hal ieu, kuring mutuskeun pikeun maénkeun sareng GitLab, diajar sacara saksama kamampuanna sareng, tangtosna, nyetél jalur pipa.

Karya ieu diideuan ku situs wéb kubernetes.io, nu dihasilkeun tina kode sumber otomatis, jeung unggal pamundut kolam renang dikirim, robot otomatis ngahasilkeun versi sawangan loka kalawan parobahan anjeun sarta nyadiakeun tumbu pikeun nempo.

Kuring nyobian ngawangun prosés anu sami ti mimiti, tapi sadayana diwangun dina Gitlab CI sareng alat gratis anu biasa kuring dianggo pikeun nyebarkeun aplikasi ka Kubernetes. Dinten ayeuna kuring tungtungna bakal nyarioskeun ka anjeun langkung seueur ngeunaan aranjeunna.

Tulisan bakal ngabahas alat sapertos:
Hugo, qbec, kaniko, git-crypt и GitLab CI kalawan kreasi lingkungan dinamis.

Eusi

1. Papanggih Hugo
2. Nyiapkeun Dockerfile
3. Ngenalkeun kaniko
4. Ngauningaan qbec
5. Nyobian Gitlab-runner sareng Kubernetes-executor
6. Deploying Helm grafik kalawan qbec
7. Ngawanohkeun git-crypt
8. Nyieun gambar toolbox
9. Pipa munggaran urang jeung assembly gambar ku tag
10. Otomatis panyebaran
11. Artefak sareng rakitan nalika ngadorong ka master
12. Lingkungan dinamis
13. Tinjauan Aplikasi

1. Ngauningaan Hugo

Salaku conto proyék urang, urang bakal nyobian nyieun situs penerbitan dokuméntasi diwangun dina Hugo. Hugo mangrupakeun generator eusi statik.

Pikeun maranéhanana anu teu wawuh jeung generator statik, Kuring gé ngabejaan Anjeun saeutik ngeunaan eta. Beda sareng mesin situs wéb konvensional sareng database sareng sababaraha PHP, anu, nalika dipénta ku pangguna, ngahasilkeun halaman dina laleur, generator statik dirancang rada béda. Éta ngamungkinkeun anjeun nyandak sumber, biasana sakumpulan file dina markup Markdown sareng témplat téma, teras kompilasi kana halaman wéb anu lengkep.

Nyaéta, salaku hasilna, anjeun bakal nampi struktur diréktori sareng sakumpulan file HTML anu dihasilkeun, anu anjeun ngan saukur tiasa unggah kana hosting anu murah sareng kéngingkeun halaman wéb anu tiasa dianggo.

Anjeun tiasa masang Hugo sacara lokal sareng cobian:

Inisialisasi situs anyar:

hugo new site docs.example.org

Sareng dina waktos anu sami gudang git:

cd docs.example.org
git init

Sajauh ieu, situs kami murni sareng supados aya anu muncul dina éta, urang kedah nyambungkeun téma heula; téma mangrupikeun sakumpulan témplat sareng aturan anu ditangtukeun ku situs kami didamel.

Pikeun téma anu bakal kami pake diajar, nu, dina pamanggih kuring, sampurna cocog pikeun situs dokuméntasi.

Abdi hoyong nengetan khusus yén urang henteu kedah nyimpen file téma dina gudang proyék urang; tibatan, urang ngan saukur tiasa nyambungkeunana nganggo git submodul:

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

Ku kituna, gudang urang bakal ngandung ukur file anu langsung patali jeung proyék urang, sarta téma disambungkeun bakal tetep salaku tumbu ka gudang husus sarta commit di dinya, nyaeta, salawasna bisa ditarik tina sumber aslina tur teu sieun. parobahan sauyunan.

Hayu urang ngabenerkeun config config.toml:

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

Parantos dina tahap ieu anjeun tiasa ngajalankeun:

hugo server

Sareng di alamat http://localhost:1313/ parios halaman wéb kami anu nembé diciptakeun, sadaya parobihan anu dilakukeun dina diréktori sacara otomatis ngapdet halaman kabuka dina browser, saé pisan!

Hayu urang coba nyieun kaca panutup dina eusi/_index.md:

# My docs site

## Welcome to the docs!

You will be very smart :-)

Screenshot tina kaca nu anyar dijieun

Pikeun ngahasilkeun situs, ngan ngajalankeun:

hugo

eusi diréktori umum/ sarta bakal ramatloka anjeun.
Sumuhun, ku jalan kitu, hayu urang geura-giru nambahkeun kana .gignignore:

echo /public > .gitignore

Tong hilap ngalaksanakeun parobahan kami:

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

2. Nyiapkeun Dockerfile

Geus waktuna pikeun nangtukeun struktur gudang urang. Kuring biasana ngagunakeun hal sapertos:

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

• dockerfiles/ - ngandung diréktori sareng Dockerfiles sareng sadaya anu dipikabutuh pikeun ngawangun gambar Docker kami.
• nyebarkeun/ — ngandung diréktori pikeun nyebarkeun aplikasi kami ka Kubernetes

Ku kituna, urang bakal nyieun Dockerfile munggaran urang sapanjang jalur dockerfiles / ramatloka / 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" ]

Sakumaha anjeun tiasa tingali, Dockerfile ngandung dua FROM, fitur ieu disebut ngawangun multi-tahap sarta ngidinan Anjeun pikeun ngaluarkeun sagalana teu perlu ti gambar docker final.
Ku kituna, gambar ahir ngan bakal ngandung poékhttpd (server HTTP lightweight) jeung umum/ — eusi halaman wéb statis kami.

Tong hilap ngalaksanakeun parobahan kami:

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

3. Ngauningaan kaniko

Salaku pembina gambar docker, kuring mutuskeun pikeun ngagunakeun kaniko, Kusabab operasi na teu merlukeun daemon docker, sarta ngawangun sorangan bisa dilumangsungkeun dina sagala mesin jeung cache nu bisa disimpen langsung dina pendaptaran, kukituna ngaleungitkeun kudu boga gudang pengkuh full-fledged.

Pikeun ngawangun gambar, ngan ngajalankeun wadahna kalawan kaniko pelaksana sareng lulus kontéks ngawangun ayeuna; ieu ogé tiasa dilakukeun sacara lokal, via 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

di mana registry.gitlab.com/kvaps/docs.example.org/website - nami gambar docker anjeun; saatos ngawangun, éta bakal otomatis diluncurkeun kana pendaptaran docker.

parameter --cache ngidinan Anjeun pikeun cache lapisan dina pendaptaran docker; pikeun conto dibikeun, aranjeunna bakal disimpen dina registry.gitlab.com/kvaps/docs.example.org/website/cache, Tapi anjeun bisa nangtukeun jalur sejen ngagunakeun parameter --cache-repo.

Potret layar tina docker-registry

4. Ngauningaan qbec

Qbec mangrupikeun alat panyebaran anu ngamungkinkeun anjeun ngajelaskeun sacara deklaratif aplikasi anjeun sareng nyebarkeunana ka Kubernetes. Ngagunakeun Jsonnet salaku sintaksis utama ngidinan Anjeun pikeun greatly simplify pedaran béda dina sababaraha lingkungan, sarta ampir sakabéhna ngaleungitkeun pengulangan kode.

Ieu tiasa hususna leres dina kasus dimana anjeun kedah nyebarkeun aplikasi ka sababaraha klaster kalayan parameter anu béda sareng hoyong ngajelaskeun sacara deklaratif dina Git.

Qbec ogé ngidinan Anjeun pikeun ngarobah Helm grafik ku ngalirkeun aranjeunna parameter diperlukeun lajeng beroperasi aranjeunna dina cara nu sarua salaku manifests biasa, kaasup anjeun bisa nerapkeun rupa mutasi ka aranjeunna, sarta ieu, kahareupna ngidinan Anjeun pikeun meunang leupas tina kabutuhan. ngagunakeun ChartMuseum. Nyaéta, anjeun tiasa nyimpen sareng ngadamel grafik langsung tina git, dimana aranjeunna milik.

Sakumaha anu kuring nyarios tadi, urang bakal nyimpen sadaya panyebaran dina diréktori nyebarkeun/:

mkdir deploy
cd deploy

Hayu urang initialize aplikasi munggaran urang:

qbec init website
cd website

Ayeuna struktur aplikasi urang sapertos kieu:

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

hayu urang tingali dina file qbec.yaml:

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

Di dieu urang utamana museurkeun spec.lingkungan, qbec parantos nyiptakeun lingkungan standar pikeun kami sareng nyandak alamat pangladén, ogé rohangan ngaran tina kubeconfig kami ayeuna.
Ayeuna nalika deploying ka standar lingkungan, qbec bakal salawasna nyebarkeun ngan ka klaster Kubernetes dieusian jeung ka namespasi dieusian, nyaeta, anjeun euweuh kudu pindah antara konteks na namespaces guna nedunan deployment a.
Upami diperlukeun, anjeun salawasna bisa ngamutahirkeun setelan dina file ieu.

Sadaya lingkungan anjeun dijelaskeun dina qbec.yaml, sareng dina file params.libsonnet, dimana eta nyebutkeun dimana meunang parameter pikeun aranjeunna.

Salajengna urang ningali dua diréktori:

• komponén / - sadaya manifests pikeun aplikasi kami bakal disimpen di dieu; aranjeunna tiasa dijelaskeun dina jsonnet sareng file yaml biasa
• lingkungan/ — di dieu urang bakal ngajelaskeun sadaya variabel (parameter) pikeun lingkungan urang.

Sacara standar kami gaduh dua file:

• lingkungan / base.libsonnet - eta bakal ngandung parameter umum pikeun sakabéh lingkungan
• lingkungan/default.libsonnet - ngandung parameter overridden pikeun lingkungan standar

hayu urang buka lingkungan / base.libsonnet sareng tambahkeun parameter pikeun komponén munggaran urang di dinya:

{
  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',
    },
  },
}

Hayu urang ogé nyieun komponén kahiji urang komponén/website.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,
                },
              },
            ],
          },
        },
      ],
    },
  },
]

Dina file ieu kami ngajelaskeun tilu éntitas Kubernetes sakaligus, nyaéta: deployment, palayanan и Ingress. Upami urang hoyong, urang tiasa nempatkeun kana komponén anu béda, tapi dina tahap ieu bakal cekap pikeun urang.

sintaksis jsonnet mirip pisan sareng json biasa, prinsipna mah, json biasa parantos sah jsonnet, janten mimitina tiasa langkung gampang pikeun anjeun nganggo jasa online sapertos yaml2json pikeun ngarobah yaml biasa anjeun kana json, atanapi, upami komponén anjeun henteu ngandung variabel naon waé, maka aranjeunna tiasa dijelaskeun dina bentuk yaml biasa.

Nalika damel sareng jsonnet Abdi nyarankeun pisan masang plugin pikeun éditor anjeun

Salaku conto, aya plugin pikeun vim vim-jsonnet, nu ngahurungkeun panyorot sintaksis tur otomatis executes jsonnet fmt unggal waktos Anjeun simpen (merlukeun jsonnet dipasang).

Sadayana parantos siap, ayeuna urang tiasa ngamimitian nyebarkeun:

Pikeun ningali naon anu urang kéngingkeun, hayu urang lakukeun:

qbec show default

Dina kaluaran, anjeun bakal ningali rendered yaml manifests anu bakal dilarapkeun ka klaster standar.

Saé, ayeuna nerapkeun:

qbec apply default

Dina kaluaran anjeun bakal salawasna ningali naon anu bakal dilakukeun dina kluster anjeun, qbec bakal naroskeun anjeun satuju kana parobihan ku ngetik y anjeun bakal tiasa mastikeun niat anjeun.

Aplikasi kami parantos siap sareng disebarkeun!

Lamun nyieun parobahan, anjeun salawasna bisa ngalakukeun:

qbec diff default

ningali kumaha parobahan ieu bakal mangaruhan deployment ayeuna

Tong hilap ngalaksanakeun parobahan kami:

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

5. Nyobian Gitlab-runner kalawan Kubernetes-eksekutor

Nepi ka ayeuna kuring ngan ukur nganggo biasa gitlab-runner dina mesin tos disiapkeun (wadahna LXC) kalawan cangkang atawa docker-eksekutor. Mimitina, kami ngagaduhan sababaraha pelari sapertos global didefinisikeun dina gitlab kami. Aranjeunna dikumpulkeun gambar docker pikeun sakabéh proyék.

Tapi sakumaha anu ditingalikeun ku prakték, pilihan ieu sanés anu paling idéal, boh tina segi praktis sareng kaamanan. Éta langkung saé sareng sacara ideologis langkung leres upami aya pelari anu misah disebarkeun pikeun tiap proyék, atanapi bahkan pikeun unggal lingkungan.

Untungna, ieu teu masalah pisan, saprak ayeuna urang bakal nyebarkeun gitlab-runner langsung salaku bagian tina proyék kami langsung di Kubernetes.

Gitlab nyayogikeun bagan helm anu siap-siap pikeun nyebarkeun gitlab-runner ka Kubernetes. Janten sadaya anu anjeun kedah laksanakeun nyaéta milarian token pendaptaran pikeun proyék kami di Setélan -> CI / CD -> Runners sareng lebetkeun ka Helm:

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

dimana:

• https://gitlab.com — alamat server Gitlab anjeun.
• yga8y-jdCusVDn_t4Wxc - token pendaptaran pikeun proyék anjeun.
• rbac.create=leres - nyadiakeun runner kalawan jumlah diperlukeun hak husus pikeun bisa nyieun pods pikeun ngalakukeun tugas urang ngagunakeun kubernetes-executor.

Lamun sagalana geus rengse neuleu, Anjeun kudu ningali hiji runner didaptarkeun dina bagian runners, dina setélan proyék anjeun.

Screenshot tina runner ditambahkeun

Éta nu basajan? - enya, éta basajan pisan! Taya deui repot jeung ngadaptar runners sacara manual, ti ayeuna runners bakal dijieun tur ancur otomatis.

6. Nyebarkeun grafik Helm kalawan QBEC

Kusabab urang mutuskeun mertimbangkeun gitlab-runner bagian tina proyék urang, éta waktuna pikeun ngajelaskeun eta dina Repository Git kami.

Urang tiasa ngajelaskeun éta salaku komponén anu misah website, tapi dina mangsa nu bakal datang urang rencanana nyebarkeun salinan béda website sering pisan, teu saperti gitlab-runner, nu bakal disebarkeun ngan sakali per klaster Kubernetes. Janten hayu urang ngamimitian aplikasi anu misah pikeun éta:

cd deploy
qbec init gitlab-runner
cd gitlab-runner

Kali ieu kami moal ngajelaskeun entitas Kubernetes sacara manual, tapi bakal nyandak bagan Helm anu siap-siap. Salah sahiji kaunggulan qbec nyaéta kamampuan pikeun ngadamel grafik Helm langsung tina gudang Git.

Hayu urang sambungkeun nganggo submodule git:

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

Ayeuna diréktori ngajual / gitlab-runner Kami ngagaduhan gudang kalayan bagan pikeun gitlab-runner.

Dina cara anu sami, anjeun tiasa nyambungkeun repositori anu sanés, contona, sadayana gudang kalayan grafik resmi https://github.com/helm/charts

Hayu urang ngajelaskeun komponén komponén/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,
  }
)

Argumen munggaran pikeun expandHelmTemplate urang lulus jalur ka grafik, lajeng params.nilai, nu urang nyokot tina parameter lingkungan, lajeng asalna objék kalawan

• nameTemplate - judul pelepasan
• ngaranspasi - namespace ditransferkeun ka Helm
• ieuFile - parameter diperlukeun nu ngalirkeun jalur ka file ayeuna
• kecap lisan - nembongkeun paréntah template helm kalayan sagala alesan nalika rendering grafik

Ayeuna hayu urang ngajelaskeun parameter pikeun komponén urang di lingkungan / base.libsonnet:

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

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

Perhatikeun runnerRegistrationToken urang nyandak tina file éksternal Rahasia/base.libsonnet, hayu urang jieun:

{
  runnerRegistrationToken: 'yga8y-jdCusVDn_t4Wxc',
}

Hayu urang pariksa lamun sagalana jalan:

qbec show default

upami sadayana beres, maka urang tiasa ngahapus sékrési kami anu parantos dikaluarkeun ku Helm:

helm uninstall gitlab-runner

sareng nyebarkeun éta cara anu sami, tapi ngalangkungan qbec:

qbec apply default

7. Bubuka keur git-crypt

Git-crypt mangrupikeun alat anu ngamungkinkeun anjeun nyetél énkripsi transparan pikeun gudang anjeun.

Ayeuna, struktur diréktori kami pikeun gitlab-runner sapertos kieu:

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

Tapi nyimpen rusiah dina Git henteu aman, nya? Janten urang kedah énkripsi leres.

Biasana, demi hiji variabel, ieu henteu salawasna asup akal. Anjeun tiasa nransper Rahasia ka qbec sareng ngalangkungan variabel lingkungan sistem CI anjeun.
Tapi perlu dicatet yén aya ogé proyék anu langkung rumit anu tiasa ngandung langkung seueur rusiah; nransferkeun sadayana ngalangkungan variabel lingkungan bakal sesah pisan.

Sumawona, dina hal ieu kuring moal tiasa nyarioskeun ka anjeun ngeunaan alat anu saé sapertos kitu git-crypt.

git-crypt Éta ogé merenah sabab ngidinan Anjeun pikeun nyimpen sakabéh sajarah Rahasia, kitu ogé ngabandingkeun, ngagabungkeun jeung ngabéréskeun konflik dina cara nu sarua salaku urang biasa ngalakukeun dina kasus Git.

Hal kahiji sanggeus instalasi git-crypt urang kedah ngahasilkeun konci pikeun gudang kami:

git crypt init

Upami anjeun gaduh konci PGP, teras anjeun tiasa langsung nambihan diri anjeun salaku kolaborator pikeun proyék ieu:

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

Ku cara ieu anjeun salawasna tiasa ngadekrip gudang ieu nganggo konci pribadi anjeun.

Upami anjeun teu gaduh konci PGP sareng henteu ngarepkeun éta, maka anjeun tiasa jalan anu sanés sareng ngékspor konci proyék:

git crypt export-key /path/to/keyfile

Ku kituna, saha anu boga hiji diékspor file konci bakal tiasa ngadekrip gudang Anjeun.

Ieu waktu pikeun nyetél rusiah kahiji urang.
Hayu atuh ngingetan yén urang masih dina diréktori nyebarkeun/gitlab-runner/, dimana urang gaduh diréktori Rahasia/, hayu urang énkripsi sadaya file di jerona, pikeun ieu kami bakal nyiptakeun file Rahasia/.gitattributes kalawan eusi handap:

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

Salaku bisa ditempo ti eusi, sadaya file masked * bakal disetir ngaliwatan git-crypt, iwal paling .gitattributes

Urang tiasa pariksa ieu ku ngajalankeun:

git crypt status -e

Kaluaran bakal janten daptar sadaya file dina gudang anu énkripsi diaktipkeun

Éta waé, ayeuna urang tiasa aman ngalaksanakeun parobihan:

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

Pikeun meungpeuk Repository, ngan ngajalankeun:

git crypt lock

sareng langsung sadaya file énkripsi bakal janten binér, moal mungkin macana.
Pikeun ngadekrip gudang, jalankeun:

git crypt unlock

8. Jieun gambar toolbox

Gambar toolbox mangrupikeun gambar sareng sadaya alat anu bakal kami anggo pikeun nyebarkeun proyék kami. Éta bakal dianggo ku runner Gitlab pikeun ngalaksanakeun tugas panyebaran khas.

Sadayana saderhana di dieu, hayu urang nyiptakeun anu énggal dockerfiles / toolbox / Dockerfile kalawan eusi handap:

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

Sakumaha anjeun tiasa tingali, dina gambar ieu kami masang sadaya utilitas anu kami dianggo pikeun nyebarkeun aplikasi kami. Kami henteu peryogi di dieu kecuali kubectl, tapi anjeun panginten hoyong maén sareng éta salami fase setelan pipa.

Ogé, supados tiasa komunikasi sareng Kubernetes sareng nyebarkeun éta, urang kedah ngonpigurasikeun peran pikeun pods anu dihasilkeun ku gitlab-runner.

Jang ngalampahkeun ieu, hayu urang buka diréktori kalawan gitlab-runner:

cd deploy/gitlab-runner

tur nambahkeun komponén anyar komponén/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,
      },
    ],
  },
]

Urang ogé bakal ngajelaskeun parameter anyar dina lingkungan / base.libsonnet, anu ayeuna siga kieu:

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',
    },
  },
}

Perhatikeun $.components.rbac.name ngarujuk kana nami pikeun komponén rbac

Hayu urang pariksa naon geus robah:

qbec diff default

sareng nerapkeun parobahan kami ka Kubernetes:

qbec apply default

Ogé, tong hilap bunuh parobahan kami ka 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. Pipa munggaran urang jeung assembly gambar ku tag

Dina akar proyék urang bakal nyieun .gitlab-ci.yml kalawan eusi handap:

.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

Punten dicatet yén kami nganggo GIT_SUBMODULE_STRATEGY: normal pikeun padamelan anu anjeun peryogikeun sacara eksplisit ngamimitian submodul sateuacan dieksekusi.

Tong hilap ngalaksanakeun parobahan kami:

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

Jigana urang bisa aman nelepon ieu versi v0.0.1 sareng tambahkeun tag:

git tag v0.0.1

Kami bakal nambihan tag iraha waé urang kedah ngaleupaskeun versi énggal. Tag dina gambar Docker bakal dihijikeun ka tag Git. Unggal push kalawan tag anyar bakal initialize ngawangun gambar kalawan tag ieu.

Hayu urang laksanakeun git push --tags, sareng hayu urang tingali jalur pipa munggaran urang:

Screenshot tina pipa munggaran

Eta sia ngagambar perhatian anjeun kanyataan yén assembly ku tag cocog pikeun ngawangun gambar docker, tapi teu cocog pikeun deploying hiji aplikasi pikeun Kubernetes. Kusabab tag anyar tiasa ditugaskeun ka komitmen anu lami, dina hal ieu, ngamimitian pipa pikeun aranjeunna bakal nyababkeun panyebaran versi anu lami.

Pikeun ngajawab masalah ieu, biasana ngawangun gambar docker dihijikeun sareng tag, sareng panyebaran aplikasi ka cabang. ngawasaan, nu versi gambar dikumpulkeun hardcoded. Ieu dimana anjeun tiasa initialize rollback ku balikan basajan ngawasaan- dahan.

10. Automation of deployment

Supados Gitlab-runner ngadekrip rahasia urang, urang kedah ngékspor konci gudang sareng nambihanana kana variabel lingkungan CI kami:

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

Urang bakal nyimpen garis hasilna dina Gitlab; pikeun ngalakukeun ieu, hayu urang buka setélan proyék kami:
Setélan -> CI / CD -> Variabel

Sareng hayu urang nyiptakeun variabel énggal:

ngetik
konci
ajen
ditangtayungan
Masked
wengkuan

File
GITCRYPT_KEY
<your string>
true (Salila latihan anjeun tiasa false)
true
All environments

Screenshot tina variabel ditambahkeun

Ayeuna hayu urang ngamutahirkeun urang .gitlab-ci.yml nambahan eta:

.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

Di dieu kami geus diaktipkeun sababaraha pilihan anyar pikeun qbec:

• --root sababaraha / aplikasi - ngidinan Anjeun pikeun nangtukeun diréktori hiji aplikasi husus
• --force:k8s-context __incluster__ - ieu variabel magic nu nyebutkeun yén deployment bakal lumangsung dina klaster sarua nu ngajalankeun gtilab-runner. Ieu diperlukeun sabab disebutkeun qbec bakal nyoba manggihan server Kubernetes cocog dina kubeconfig Anjeun
• --antosan - maksa qbec antosan dugi sumberdaya eta nyiptakeun asup kana kaayaan Siap sarta ngan lajeng kaluar kalawan suksés kaluar-kode.
• -enya - ngan saukur nganonaktipkeun cangkang interaktif Naha anjeun yakin? nalika deployed.

Tong hilap ngalaksanakeun parobahan kami:

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

Sarta sanggeus git nyorong urang bakal ningali kumaha aplikasi kami parantos disebarkeun:

Screenshot tina pipa kadua

11. Artefak jeung assembly nalika ngadorong master

Ilaharna, léngkah-léngkah anu dijelaskeun di luhur cekap pikeun ngawangun sareng nganteurkeun ampir sadaya jasa mikro, tapi kami henteu hoyong nambihan tag unggal waktos urang kedah ngapdet situs. Ku alatan éta, urang bakal nyandak jalur anu langkung dinamis sareng nyetél panyebaran nyerna dina cabang master.

Idena basajan: ayeuna gambar urang website bakal diwangun deui unggal waktos Anjeun nyorong kana ngawasaan, lajeng otomatis nyebarkeun ka Kubernetes.

Hayu urang ngapdet dua padamelan ieu di urang .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"

Punten dicatet yén kami parantos nambihan benang ngawasaan к réf pikeun jobs build_website sarta kami ayeuna make $CI_COMMIT_REF_NAME tibatan $CI_COMMIT_TAG, nyaeta, urang untied tina tag di Git tur ayeuna urang bakal nyorong hiji gambar kalawan nami cabang commit nu initialized pipa nu. Eta sia noting yén ieu ogé bakal bisa dipaké jeung tag, nu bakal ngidinan urang pikeun ngahemat snapshots loka kalawan versi husus dina docker-pendaptaran.

Nalika nami tag docker pikeun vérsi énggal tina situs éta tiasa dirobih, urang tetep kedah ngajelaskeun parobihan kana Kubernetes, upami henteu, éta ngan saukur moal nyebarkeun deui aplikasi tina gambar énggal, sabab éta moal aya perhatikeun parobahan dina deployment manifest.

Pilihan —vm:ext-str digest=”$DIGEST” pikeun qbec - ngidinan Anjeun pikeun lulus variabel éksternal mun jsonnet. Kami hoyong éta di-redeployed dina kluster sareng unggal sékrési aplikasi kami. Urang henteu deui tiasa nganggo nami tag, anu ayeuna tiasa teu tiasa dirobih, sabab urang kedah dihijikeun kana versi gambar anu khusus sareng micu panyebaran nalika robih.

Di dieu urang bakal dibantosan ku kamampuan Kaniko pikeun nyimpen gambar nyerna kana file (option --digest-file)
Teras we bakal nransper file ieu sareng maca dina waktos nyebarkeun.

Hayu urang ngamutahirkeun parameter pikeun urang deploy/website/environments/base.libsonnet nu ayeuna bakal kasampak kawas kieu:

{
  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',
    },
  },
}

Rengse, ayeuna aya komitmen ngawasaan initializes ngawangun gambar docker pikeun website, teras sebarkeun ka Kubernetes.

Tong hilap ngalaksanakeun parobahan kami:

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

Urang parios engké git nyorong urang kedah ningali sapertos kieu:

Potret layar pipa pikeun master

Sacara prinsip, urang teu kedah redeploy gitlab-runner kalawan unggal push, iwal, tangtosna, nanaon geus robah dina konfigurasi na, hayu urang ngalereskeun eta dina .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/**/*

parobahan bakal ngidinan Anjeun pikeun ngawas parobahan dina nyebarkeun/gitlab-runner/ sarta bakal memicu pakasaban urang ngan lamun aya wae

Tong hilap ngalaksanakeun parobahan kami:

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

git nyorong, éta hadé:

Potret layar pipa anu diropéa

12. Lingkungan dinamis

Waktosna pikeun ngabédakeun pipa kami sareng lingkungan dinamis.

Mimiti, hayu urang ngapdet padamelan build_website di urang .gitlab-ci.yml, miceun blok ti dinya ngan, anu bakal maksakeun Gitlab pikeun memicu éta dina sagala komitmen ka cabang mana waé:

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/

Lajeng ngamutahirkeun pakasaban deploy_website, tambahkeun blok di dinya lingkungan:

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"

Ieu bakal ngamungkinkeun Gitlab ngahubungkeun padamelan éta produksi lingkungan sareng ningalikeun tautan anu leres.

Ayeuna urang tambahkeun dua padamelan deui:

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

Aranjeunna bakal diluncurkeun nalika nyorong kana cabang naon waé kecuali master sareng bakal nyebarkeun versi sawangan situs éta.

Kami ningali pilihan anyar pikeun qbec: --app-tag — éta ngamungkinkeun anjeun pikeun méré tag versi aplikasi anu disebarkeun sareng ngan ukur dianggo dina tag ieu; nalika nyiptakeun sareng ngancurkeun sumber daya di Kubernetes, qbec ngan ukur tiasa dianggo sareng aranjeunna.
Ku cara ieu urang moal tiasa nyiptakeun lingkungan anu misah pikeun tiap ulasan, tapi ngan ukur nganggo deui anu sami.

Di dieu urang ogé ngagunakeun qbec nerapkeun review, sabalikna qbec nerapkeun standar - Ieu mangrupikeun waktos nalika urang bakal nyobian ngajelaskeun bédana pikeun lingkungan urang (review sareng standar):

Hayu urang tambahkeun tingalian lingkungan di deploy/website/qbec.yaml

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

Teras we bakal nyatakeun dina deploy/website/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

Sareng tuliskeun parameter khusus pikeun éta deploy/website/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',
    },
  },
}

Hayu urang ogé nyandak katingal ngadeukeutan di jobu stop_review, éta bakal dipicu nalika cabangna dihapus sareng ku kituna gitlab henteu nyobian mariksa éta dianggo GIT_STRATEGY: euweuh, engke urang clone ngawasaan-cabang sareng ngahapus ulasan ngalangkungan éta.
Éta rada ngabingungkeun, tapi kuring henteu acan mendakan jalan anu langkung saé.
Hiji pilihan alternatif bakal nyebarkeun unggal review ka ngaranspasi hotél, nu salawasna bisa dibongkar sagemblengna.

Tong hilap ngalaksanakeun parobahan kami:

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

git nyorong, git Checkout -b test, git push test asal, pariksa:

Potret layar lingkungan anu diciptakeun di Gitlab

Sagalana jalan? - saé, hapus cabang uji kami: git Checkout master, git push asal: test, urang pariksa yen jobs ngahapus lingkungan digawé tanpa kasalahan.

Di dieu Abdi hoyong geuwat netelakeun yen sagala pamekar dina proyék bisa nyieun cabang, anjeunna ogé bisa ngarobah .gitlab-ci.yml file jeung aksés variabel rusiah.
Ku alatan éta, niatna dianjurkeun pikeun ngidinan pamakéan maranéhanana ngan pikeun cabang ditangtayungan, contona dina ngawasaan, atawa nyieun set misah variabel pikeun tiap lingkungan.

13. Review Aplikasi

Tinjauan Aplikasi Ieu mangrupikeun fitur GitLab anu ngamungkinkeun anjeun nambihan tombol pikeun unggal file dina gudang pikeun gancang ningalina dina lingkungan anu disebarkeun.

Supados tombol ieu némbongan, anjeun kedah nyiptakeun file .gitlab/rute-map.yml sareng nerangkeun sadaya transformasi jalur di dinya; dina hal urang bakal saderhana pisan:

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

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

Tong hilap ngalaksanakeun parobahan kami:

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

git nyorong, sareng pariksa:

Potret layar tombol Review App

Pakasaban réngsé!

Sumber proyék:

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

Hatur nuhun kana perhatosanana, mugia anjeun resep

sumber: www.habr.com