ProHoster > Блог > administratio > Quaerens nova instrumenta aedificandi et automandi instruere in Kubernetes

Quaerens nova instrumenta aedificandi et automandi instruere in Kubernetes

Quaerens nova instrumenta aedificandi et automandi instruere in Kubernetes

Salve! Nuper multa instrumenta automationis refrigerantia dimissa sunt tum ad imagines aedificandas Docker et ad Kubernetes instruere. Hac de re placuit cum GitLab circum ludere, eius facultates penitus perscrutari et, sane, pipelinem constituere.

Hoc opus inspiratum a website kubernetes.ioquod generatur ex source codes automatice, et pro unaquaque piscina rogatu misso, robot automatice versionem loci praevisum cum mutationibus tuis gignit et nexum videndi praebet.

Similem processum de scabere conabar aedificare, sed plane in Gitlab CI constructum et instrumenta libera, quibus usus sum utens ad applicationes ad Kubernetes explicandas. De his tandem tibi hodie plura dicam.

De instrumentis ut de articulis disseremus:
Hugo, qbec, kaniko, git-crypt и C. GitLab cum creatione dynamicae progressionis.

Contentus

  1. Occursum Hugoni
  2. Praeparans Dockerfile
  3. Ut cognoscat kaniko
  4. Ut cognoscat qbec
  5. Conatus Gitlab-cursor apud Kubernetes executor
  6. Chartas Helm disponas cum qbec
  7. Introducendis git-crypt
  8. Imaginem creando toolbox
  9. Prima pipeline et conventus imaginum per tags
  10. Automation instruere
  11. Artificia et conventus impellendo ad dominum
  12. Dynamic ambitus
  13. Review Apps

1. ut cognoscat Hugo

Exemplum propositi nostri, documenta editae in Hugone situm creare conabimur. Hugo static contentus generator est.

Pro quibus static generantibus noti sunt, de his paulo plura dicam. Dissimiles machinae institutoriae cum database et quibusdam PHP, quae ab usore petitae paginas in musca generant, generatores statice paulo aliter designantur. Permittunt te accipere fontes, plerumque tabellarum copiae in Markdown markup et thema templates, deinde eas compilare in loco perfecto perfecto.

Hoc est, ex consequenti, directorium structuram ac seriem HTML imaginum generatarum accipies, quae simpliciter cuilibet vili obnoxio et laboranti website imponere potes.

Hugonem localiter instituere potes et eum experior:

Novum site initializing:

hugo new site docs.example.org

Simulque git repositio;

cd docs.example.org
git init

Hactenus noster situs pristinus est et ut aliquid in eo appareat, primum opus est thema connectere: thema is just a set of templates and specified rules by which our site is generated.

Pro themate utemur Discequae, mea quidem sententia, ad locum documentorum aptissima est.

Velimus sedulo animadvertimus quod in repositorio nostro thema imaginum servare non opus est, sed simpliciter illud per coniungere possumus. git submodule:

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

Ita repositorium nostrum continebit tantum fasciculos directe ad nostrum propositum relatos, et thema connexum remanebit ut nexum cum reposito specifico et commissum in eo, hoc est, semper ab originali fonte extrahi et timere non potest. mutationibus repugnat.

Sit scriptor corrigere aboutconfig config.toml:

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

Iam in hac scaena currere potes;

hugo server

Et in inscriptione http://localhost:1313/ reprehendo nostrum website nuper creatum, omnes mutationes factae in indicem automatice update paginam apertam in navigatro, commodissime!

Sit scriptor pagina operimentum creare experimentum content/_index.md:

# My docs site

## Welcome to the docs!

You will be very smart :-)

Screenshot paginae nuper creatae

Quaerens nova instrumenta aedificandi et automandi instruere in Kubernetes

Situm generare, mox currere;

hugo

Indicis contenta public/ et in website tuum erit.
Immo obiter eam statim adiciamus .gitignore:

echo /public > .gitignore

Mutationes nostras committere noli oblivisci:

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

2. Praeparans Dockerfile

Tempus est repositorii structuram definire. Soleo uti aliquid simile;

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

  • dockerfiles/ - directoria continent cum Dockerfiles et omnia necessaria ad imagines fabricandas nostras Docker.
  • explicandam/ - continet directoria ad applicationes nostras ad Kubernetes explicandas

Sic primum Dockerfile per viam creabimus dockerfiles/website/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" ]

Ut videre potes, Dockerfile duos contineat a, haec factura appellatur multi scaena constructum ac permittit ut omnia quae superflua sunt ab ultima Docker imagine excludas.
Sic ultima imago tantum continebit darkhttpd (LEVUS HTTP server) et public/ - Summa nostri stabiliter generatae website.

Mutationes nostras committere noli oblivisci:

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

3. Ut cognoscat kaniko

Sicut fabricator imaginis auctor, ego uti decrevi kanikoCum eius operatio non requirit daemonem dolitorem, et ipsa constructio quavis machina peragi potest et cella directe in registro condi potest, eo quod removeatur necesse est ut repositione plenae discursationis pertinax sit.

Condere imaginem, mox vas cum currunt kaniko executor et transitum hodiernam contextus aedificandi, quod etiam localiter fieri potest, per scopo:

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

quibus registry.gitlab.com/kvaps/docs.example.org/website - nomen imaginis tuae, cum aedificatur, automatice in registrum scopulorum deducetur.

parametri --cache sino vos ut strata cache in subcriptio Faucibus, exempli gratia, fient in registry.gitlab.com/kvaps/docs.example.org/website/cache, sed aliam semitam uti potes modulo --cache-repo.

Tortor de docker-subcriptio

Quaerens nova instrumenta aedificandi et automandi instruere in Kubernetes

4. ut cognoscat qbec

Qbec instrumentum instruere est quod permittit ut declarative applicationem tuam describere manifestat ac eas Kubernetes explicet. Utens Jsonnet sicut syntax principalis sinit te valde simpliciorem reddere descriptionem differentiarum per multiplices ambitus, et etiam paene omnino eliminat codicem repetitio.

Hoc maxime verum esse potest in casibus in quibus applicationem ad plures ligaturas cum diversis parametris explicandas opus est et eas in Git declarare voles.

Qbec etiam tibi permittit ut Helm chartulas in transeundo parametros necessarias redderes, ac deinde eas eodem modo ac manifestas regulares operare, in iis varias mutationes in iis adhibere potes, et hoc vicissim tibi permittit ut necessitas careat. uti ChartMuseum. Id est, condere potes et reddere chartulas directe ex git, ubi sunt.

Ut ante dixi, omnia opera in directorio recondimus explicandam/:

mkdir deploy
cd deploy

Lets initialize nostram primam applicationem;

qbec init website
cd website

Iam forma applicationis nostrae hoc spectat:

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

Intueamur tabella qbec.yaml:

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

Hic imprimis interest in spec.environments, qbec iam defaltam environment pro nobis creavit et inscriptionem servo electronicam accepit, necnon spatii spatii e kubeconfig currente nostro.
Nunc cum disponas ad default ambitus, qbec solum ad botrum Kubernetes determinatum et ad certum spatium nominandum explicabit, hoc est, iam non debes commutare inter contextus et spatiis nomina ad instruere.
Si opus est, semper occasus in hoc documento renovare potes.

Omnes ambitus tuos describuntur qbec.yamlet in tabella params.libsonnetubi dicitur ubi parametri sunt.

Deinde videmus duos directoria:

  • components / — omnes manifestationes ad applicationem nostram hic reponendae sunt, describi possunt tam in jsonnet quam in imagini yaml regulari
  • ambitus/ — hic omnes variabiles ambitus nostros (parametri) describemus.

Per default duos ordines habemus:

  • environments/base.libsonnet - communes parametros continebit pro omnibus ambitibus
  • environments/default.libsonnet - continet ambitum overridden ad environment default

aperta est environments/base.libsonnet et adde parametros pro primo nostro ibi componente;

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

Sit scriptor etiam creare primam partem components/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,
                },
              },
            ],
          },
        },
      ],
    },
  },
]

In hoc fasciculo tria entia Kubernetes statim descripsimus, haec sunt: instruere, obsequium и Ingress. Si vellemus, possemus eas in varias partes ponere, sed una adhuc satis erit nobis.

Syntax jsonnet simillimum est regulari json, in principio, regularis json iam valet jsonnet, sic primo facilius tibi erit utere online officia sicut yaml2json consuetum tuum yaml in json convertere, vel, si partes tuae variabiles non continent, forma regularis yaml describi possunt.

Cum opus est jsonnet EGO altus suadeo installing plugin pro editor

Exempli gratia, plugin pro vim vim-jsonnet, quod syntaxin volvitur elucidando et ipso facto perficit jsonnet fmt omne tempus servas (instituitur jsonnet requirit).

Omnia parata sunt, iam explicari incipimus;

Ut quid cepimus, curramus;

qbec show default

In output, videbis yaml redditum manifestat quod botrum default applicabitur.

Magna nunc applicare;

qbec apply default

In output semper videbis quid in botro tuo fiet , qbec rogabit te ut consentias typing mutationes . y voluntates tuas confirmare poteris.

Nostra applicatio parata est et explicatur!

Si mutas, semper potes;

qbec diff default

videre quomodo hae mutationes accidunt instruere currentem

Mutationes nostras committere noli oblivisci:

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

5. Conatus Gitlab-cursor apud Kubernetes executor

Usque nuper tantum usus est regularis gitlab-cursor in machina praeparata (LXC continens) concha seu docker-exsecutor. Initio complures tales cursores globally in gitlab nostra definitos habuimus. Navale imagines omnium inceptorum colligebant.

Sed ut praxis ostendit, haec optio non est optima, tam ratione practicae et salutis. Multo melius est et ideologiam rectius habere singulas cursores ad singulas res, vel etiam ad singulas ambitus explicandas.

Fortunate haec quaestio omnino non est, quia nunc explicabimus gitlab-cursor directe ad partem nostri consilii juris in Kubernetes.

Gitlab chartam gubernaculo paratam factam praebet ad gitlab-cursorem ad Kubernetes explicandam. Itaque omne opus facere est invenire adnotatione firmitatis indicium ad nostrum project in Optiones -> CI / CD -> Runners gubernare et consequentes;

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

ubi:

  • https://gitlab.com — inscriptione servo tuo Gitlab.
  • yga8y-jdCusVDn_t4Wxc - adnotatione tessera ad propositum tuum.
  • rbac.create = veri — Cursorem praebet necessaria privilegiorum copia ut siliquas creare possit ad officia nostra exercenda utendo kubernetes-executore.

Si omnia recte aguntur, cursorem relatus in sectione videre debes Cursor, in occasus project.

Tortor additae cursor

Quaerens nova instrumenta aedificandi et automandi instruere in Kubernetes

Estne simplex? - Immo simplex est! Nulla plus hassle cum cursoribus manualibus perscriptum, posthac cursores automatice creabuntur et delebuntur.

6. Deploy Helm chartis cum QBEC

Cum considerare decrevimus gitlab-cursor pars propositi nostri est tempus describere in repositorio nostro Git.

Non potuimus describere componentes separatum websitesed in posterum diversis exemplaribus disponere disponimus website persaepe, unlike gitlab-cursorquae semel tantum per Kubernetes botrum explicabuntur. Sit scriptor initialize applicationem separatam pro eo:

cd deploy
qbec init gitlab-runner
cd gitlab-runner

Hoc tempore Kubernetes res manuales non describemus, sed chartulam Helm paratam capiemus. Una commoda qbec facultas est reddendi Helm chartis directe ex Git reposito.

Coniungamus eam utendo submodule:

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

Nunc indicem venditor/gitlab-cursor Reconditorium habemus cum chartula pro cursore gitlab.

Simili modo repositoria alia coniungere potes, exempli gratia, totum repositum cum chartis officialibus https://github.com/helm/charts

Sit scriptor describere componentibus components/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,
  }
)

Prima ratio to expandHelmTemplate transeamus iter chartula, deinde params.valuesquam ex ambitu ambitu capimus, tum objectum

  • nameTemplate - release nomen eius
  • fasciculorum impositorum - spatio nominali transfertur ad gubernacula
  • thisFile - requiritur modulus qui transit iter ad lima
  • verbosus - ostendit imperium gubernaculum template omnibus rationibus reddens chart

Nunc parametris nostris componentibus describimus environments/base.libsonnet:

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

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

placere note runnerRegistrationToken nos ab externa file secreta/base.libsonnetcrearemus:

{
  runnerRegistrationToken: 'yga8y-jdCusVDn_t4Wxc',
}

Si omnia opera scriptor reprehendo:

qbec show default

si omnia in ordine sunt, delere possumus nostram remissionem antea per Helm:

helm uninstall gitlab-runner

et eodem modo explicant, sed per qbec;

qbec apply default

7. Introducendis git-crypt

Git-crypt instrumentum est quod permittit tibi encryptionem pellucidam erigere pro repositorio tuo.

In momento, nostri directorii structura pro cursore gitlab hoc simile videtur:

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

Sed secreta recondere in Git tutum non est? Itaque necesse est eas recte encrypt.

Usitas, unius variabilis causa, hoc non semper convenit. Secreta transferre potes qbec et per variabiles ambitus systematis CI tui.
Sed memorabile est etiam plura incepta esse quae plura secreta continere possint, ea omnia transferre per variabiles ambitus difficiliores erunt.

Hoc autem in casu nolui de tam mirifico instrumento narrare git-crypt.

git-crypt Convenit etiam in eo quod permittit te totam historiam secretorum servare, ac certamina comparare, confundi et resolvere eodem modo, sicut nos in Git agere consuevimus.

Primum est post institutionem git-crypt necesse est claves generare pro reposito nostro:

git crypt init

Si PGP clavem habes, te statim addere potes adiutorem huius rei:

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

Hoc modo semper minuere potes hoc repositorium privatis clavibus utens.

Si PGP clavem non habes et eam non exspectas, alia via ire potes et clavis documenti exportare:

git crypt export-key /path/to/keyfile

Sic quicunque exportatum habet keyfile minui poterit repositio.

Tempus est secretum primum constituere.
Fac me admonere te nos adhuc esse in indicem explicandam/gitlab-runner/, ubi habemus directorium secreta/, omnes tabellas encryptas in eo, hoc enim fasciculum creabimus secreta /.gitattributes cum sequenti contenti:

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

Ut ex contento videri potest, omnia fascicula palliata sunt * ejicietur per git-cryptnisi magna .gitattributes

Hoc per currit possumus reprehendo:

git crypt status -e

In output erit index omnium imaginum in promptuario pro quibus encryption potest

Actum est, nunc tuto mutationes nostras committere;

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

Repositorium claudere, mox currere;

git crypt lock

statimque omnes fasciculi encrypted in binarii aliquid convertent, eas legere impossibile erit.
Minuta repositio, currite;

git crypt unlock

8. crea in toolbox imaginem

Instrumenti instrumenti imago est imago cum omnibus instrumentis quibus ad nostrum propositum explicandum utemur. Adhibebitur a cursore Gitlab ad operas instruere typicas.

Omnia hic simplicia sunt, novum crearemus dockerfiles / toolbox / Dockerfile cum sequenti contenti:

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

Ut vides, in hac imagine instituimus omnes utilitates quas ad nostram applicationem explicandam usi sumus. Non opus est hic nisi kubectlsed circum ludere cum eo in pipelineo phase videres.

Item, ut cum Kubernetes communicare possit et ad eam explicandam, opus est ut siliquas quae a gitlab cursore generatae sunt configurare.

Hoc ut facias, eamus in indicem cum cursore gitlab;

cd deploy/gitlab-runner

et adde novam component components/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,
      },
    ],
  },
]

Nos quoque novum ambitum describere environments/base.libsonnetqui nunc similis est;

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

placere note $.components.rbac.name refertur ad nomine nam componentibus rbac

Sit scriptor reprehendo quod mutatum est:

qbec diff default

et nostras mutationes ad Kubernetes applicamus;

qbec apply default

Etiam, mutationes nostras committere noli oblivisci 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. Primus noster pipeline et conventus imaginum per tags

Ad radicem project erimus .gitlab-ci.yml cum sequenti contenti:

.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

Lorem utimur GIT_SUBMODULE_STRATEGY: normal pro illis in quibus opus est explicite initialize submodules ante executionem.

Mutationes nostras committere noli oblivisci:

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

Puto nos hanc versionem tuto appellare v0.0.1 et tag adde:

git tag v0.0.1

Quotiens tags novam versionem dimittere necesse est. Tags in Docker imagines ligabuntur ad Git tags. Singulae ventilationes cum novo tag initialize imaginum fabricam cum hoc tag.

praestare git dis --tagset inspiciamus primum nostrum pipelinum;

Screenshot primi pipeline

Quaerens nova instrumenta aedificandi et automandi instruere in Kubernetes

Operae pretium est animum intendere ad quod conventus per tags aptus est ad imagines fabricandas, sed ad applicationem Kubernetes explicandas non convenit. Cum novae tags assignari possunt veteribus committis, hoc in casu, initialis fistulae earum ad veterem versionem instruere possunt.

Ad hanc solvendam quaestionem plerumque imagines schoenariorum fabricare ad tags ligatur et applicationem ad ramum instruere dominusin quibus versiones imaginum collectarum indurata sunt. Hoc est ubi reverti potes initialize cum simplici reverti dominus— sarmenta.

10. Automation de instruere

Ut ad Gitlab-cursorem ad decrypt secreta nostra, repositorium clavem exportare debebimus et eam nostris ci ambitus variabilibus addere;

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

Lineam consequens Gitlab servabimus, hoc facere, ad unctiones nostras project eamus:
Optiones -> CI / CD -> Variabiles

Et novum variabile crearemus:

Type
Key
Value
tutis
Masked
scope

File
GITCRYPT_KEY
<your string>
true (Per disciplina potes false)
true
All environments

Screenshot additae variabilis

Quaerens nova instrumenta aedificandi et automandi instruere in Kubernetes

Nunc lets 'renovatio nostra' .gitlab-ci.yml addidisset;

.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

Hic aliquot novas optiones pro qbec potuimus:

  • --root quidam / app * - sino vos determinare indicem certae applicationis
  • --force:k8s-context __incluster__ - Haec variabilis magica est quae dicit instruere in eodem botro fieri in quo cursor gtilab currit. Hoc necessarium est, quia aliter qbec idoneum Kubernetes servo tuo in kubeconfig invenire conabitur
  • --manere — copiae qbec exspectandae sunt donec facultates quas creat in promtu eant statum et tunc demum cum felici exitu exeant.
  • -yes - simpliciter priuat interactive testa Es certus? cum perrexerunt.

Mutationes nostras committere noli oblivisci:

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

Et post git dis videbimus quo modo explicandae sint applicationes nostrae;

Screenshot secundi pipeline

Quaerens nova instrumenta aedificandi et automandi instruere in Kubernetes

11. Artificia et conventus cum strenuo domino

Gradus supra descriptos typice sufficiunt ad aedificandum et tradendum quodlibet fere microservicium, sed nolumus addere quotienscumque opus est ad locum renovandum. Ergo dynamicam viam capiemus et digestum in ramo magistri constituemus.

Idea simplex est: imago nunc nostri website reaedificabitur omni tempore ventilabis in dominusac deinde ipso facto ad Kubernetes explicant.

Haec duo jobs in nostro update scriptor .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"

Quaeso nota adiecimus filo dominus к Non enimf respicit pro jobs build_website et nunc utimur $CI_COMMIT_REF_NAME pro $CI_COMMIT_TAG, hoc est, a tags in Git solvimur et nunc imaginem trudemus cum nomine rami commissi qui pipeline initialem instruxit. Notatu dignum est hoc etiam cum tags operari, quod nos permittet ut cum specifica versione in actis subcriptio snapshots servare.

Cum nomen inceptorum pro nova versione situs immutatum esse potest, adhuc habemus mutationes Kubernetes describere, alioquin simpliciter applicationem ex nova imagine non reddet, cum nullas mutationes in notabit. instruere manifest.

optionem -vm: ext-str digestum "$ DIGEST" nam qbec - sino te transire externam variabilem ad jsonnet. Volumus eam in botro reddi cum applicationis nostrae solutione unaquaque. Nomine tag nomen iam uti non possumus, quod iam incommutabile esse potest, cum certae imaginis versioni ligari necesse est ac felis instruere cum mutat.

Hic adiuvabimus facultatem Kaniko servandi imaginem digestam in tabella (option --digest-file)
Tunc hunc fasciculum transferemus et in tempore instruemus.

Lets parametri renovatio nostro deploy/website/environments/base.libsonnet qute nunc vide sicut hoc;

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

Actum, nunc aliquo committo dominus initializes constructum de docker imago for websiteatque inde Kubernetes explicant.

Mutationes nostras committere noli oblivisci:

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

Nos reprehendo eam postea git dis videndum est aliquid simile hoc;

Screenshot de pipeline pro domino

Quaerens nova instrumenta aedificandi et automandi instruere in Kubernetes

In principio, cursorem gitlabrum cum singulis dis reddere non necesse est, nisi certe nihil mutatum est in eius configuratione, illud figamus in .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/**/*

mutationes permittet ut monitor mutationes in explicandam/gitlab-runner/ et felis nostrum officium tantum si quae sunt

Mutationes nostras committere noli oblivisci:

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

git dis, melior est:

Screenshot de updated pipeline

Quaerens nova instrumenta aedificandi et automandi instruere in Kubernetes

12. Dynamic ambitus

Tempus est nostri pipelines variare cum ambitus dynamicos.

Primum, officium renovatio build_website in nobis .gitlab-ci.ymlsublatis scandalum ex eo tantum, quae coget Gitlab felis aliquam committere ramo;

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/

Tunc update officium deploy_websiteAdde ibi truncum environment:

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"

Hoc permittet Gitlab cum officium commisceri PRODI environment et rectam nexum ad eam ostendunt.

Nunc duo plura jobs addere:

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

Immittentur in dis ad quaslibet ramos praeter magistrum et explicant versionem praeviam loci.

Qbec pro nova optione videmus; --app-tag - permittit ut versiones applicationis et operae in hoc tag solo tantum explices, cum opes in Kubernetes creando et destruendo, qbec solum cum illis operabitur.
Hoc modo separatum ambitum singulis recensendis creare non possumus, sed simpliciter eandem reuse.

Hic etiam utimur qbec applicare recensionem, pro * qbec applicare default - Hoc prorsus momentum est, cum differentias ambituum nostrorum (recensio et defectu) describere conabimur;

adde review amet in explicandam/website/qbec.yaml

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

Tunc declarabimus illud in 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

Morem parametri scribe pro eo in 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',
    },
  },
}

Sit etiam inspiciat jobu stop_reviewurguetur, cum ramus deletus est et ut gitlabum checkout adhibitum esse non conetur GIT_STRATEGY: nemoPostea clone dominus-branch et recensionem delere per eam.
Paululum confusum est, sed adhuc viam pulchriorem non inveni.
Vel optio erit singulas recensiones explicandi ad spatium spatii deversorium, quod semper omnino divelli potest.

Mutationes nostras committere noli oblivisci:

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

git dis, git Checkout b test, git dis originem test, reprehendo:

Screenshot in ambitibus creatum Gitlab

Quaerens nova instrumenta aedificandi et automandi instruere in Kubernetes

Omnia laborat? - Magnum, dele nostrum test ramum; Checkout git dominum, git dis originem: test, reprimimus jobs delendo ambitum sine erroribus laboravisse.

Hic statim declarare libet quod quaelibet elit in incepto potest ramos creare, potest etiam mutare .gitlab-ci.yml file and access secret variables.
Ideo enixe commendatur ut eorum usus tantum in ramis munitis permittat, v.gr dominusaut variabilium singularum rerum ambitum efficiant.

13. Review Apps

Review Apps Hoc pluma GitLab est quae tesseram cuiusque fasciculi in repositorio addere sinit ut cito illam in ambitu rerum inspicias.

Ut hae tesserae appareant, fasciculum creare debes .gitlab/route-map.yml et describe in ea omnem viam transformationum, in nobis valde simplex erit;

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

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

Mutationes nostras committere noli oblivisci:

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

git disdeprime;

Screenshot of the Review App button

Quaerens nova instrumenta aedificandi et automandi instruere in Kubernetes

Iob est!

Fontes project:

Tibi gratias ago pro animo tuo, spero te amare Quaerens nova instrumenta aedificandi et automandi instruere in Kubernetes

Source: www.habr.com

Add a comment