🥇Canary inplementazioa Kubernetes #1: Gitlab CI

Gitlab CI eta eskuzko GitOps erabiliko ditugu Kubernetesen Canary inplementazioa inplementatzeko eta erabiltzeko

Serie honetako artikuluak:

(Artikulu hau)
Kanariar Inplementazioa ArgoCI erabiliz
Kanariarren hedapena Istio erabiliz
Kanariar Inplementazioa Jenkins-X Istio Flagger erabiliz

Canary inplementazioa eskuz egingo dugu GitOps bidez eta Kubernetes baliabide nagusiak sortuz/aldatuz. Artikulu hau sarrera egiteko da batez ere Kubernetes Canary-en inplementazioak nola funtzionatzen duen, automatizazio metodo eraginkorragoak baitaude, hurrengo artikuluetan kontuan hartuko ditugunak.

https://www.norberteder.com/canary-deployment/

Kanariarren hedapena

Canary estrategiarekin, eguneraketak erabiltzaileen azpimultzo bati soilik aplikatzen zaizkio. Monitorizazioaren, erregistro-datuen, eskuzko probaren edo beste iritzi-kanal batzuen bidez, bertsioa probatzen da erabiltzaile guztiei kaleratu aurretik.

Kubernetes inplementazioa (eguneratze iraunkorra)

Kubernetes Deployment-en estrategia lehenetsia eguneratzea da, non pods kopuru jakin bat abiarazten den irudien bertsio berriekin. Arazorik gabe sortu badira, irudien bertsio zaharrak dituzten lekak amaitu egiten dira, eta paraleloki berriak sortzen dira.

GitOps

Adibide honetan GitOps erabiltzen dugu zeren eta:

Git egia iturri bakar gisa erabiliz
Git Eragiketak erabiltzen ditugu eraikitzeko eta inplementatzeko (ez da beharrezkoa git tag/merge ez den komandorik)

Adibidea

Har dezagun praktika on bat: aplikazioaren kodearen biltegi bat eta azpiegiturarako biltegi bat edukitzea.

Aplikazioen biltegia

Oso sinplea den Python+Flask API bat da, erantzun bat JSON gisa itzultzen duena. Paketea GitlabCI bidez eraikiko dugu eta emaitza Gitlab Erregistrora eramango dugu. Erregistroan bi bertsio ezberdin ditugu:

wuestkamp/k8s-deployment-example-app:v1
wuestkamp/k8s-deployment-example-app:v2

Haien arteko desberdintasun bakarra itzulitako JSON fitxategiaren aldaketa da. Aplikazio hau zein bertsiorekin komunikatzen garen ahalik eta errazen ikusteko erabiltzen dugu.

Azpiegituren biltegia

Arbi honetan GitlabCI bidez zabalduko dugu Kubernetesera, .gitlab-ci.yml Honako hau da:

image: traherom/kustomize-docker

before_script:
   - printenv
   - kubectl version

stages:
 - deploy

deploy test:
   stage: deploy
   before_script:
     - echo $KUBECONFIG
   script:
     - kubectl get all
     - kubectl apply -f i/k8s

   only:
     - master

Zuk zeuk exekutatzeko kluster bat beharko duzu, Gcloud erabil dezakezu:

gcloud container clusters create canary --num-nodes 3 --zone europe-west3-b

gcloud compute firewall-rules create incoming-80 --allow tcp:80

Sardexka egin behar duzu https://gitlab.com/wuestkamp/k8s-deployment-example-canary-infrastructure eta aldagai bat sortu KUBECONFIG GitlabCIn, sarbidea izateko konfigurazioa edukiko duena kubectl zure multzora.

Kluster baterako kredentzialak nola lortu (Gcloud) irakur dezakezu hemen.

Azpiegitura Yaml

Azpiegitura biltegian zerbitzua dugu:

apiVersion: v1
kind: Service
metadata:
 labels:
   id: app
 name: app
spec:
 ports:
 - port: 80
   protocol: TCP
   targetPort: 5000
 selector:
   id: app
 type: LoadBalancer

Eta hedapena barne deploy.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
 name: app
spec:
 replicas: 10
 selector:
   matchLabels:
     id: app
     type: main
 template:
   metadata:
     labels:
       id: app
       type: main
   spec:
     containers:
     - image: registry.gitlab.com/wuestkamp/k8s-deployment-example-app:v1
       name: app
       resources:
         limits:
           cpu: 100m
           memory: 100Mi

Eta beste hedapen bat deploy-canary.yaml:

kind: Deployment
metadata:
 name: app-canary
spec:
 replicas: 0
 selector:
   matchLabels:
     id: app
     type: canary
 template:
   metadata:
     labels:
       id: app
       type: canary
   spec:
     containers:
     - image: registry.gitlab.com/wuestkamp/k8s-deployment-example-app:v2
       name: app
       resources:
         limits:
           cpu: 100m
           memory: 100Mi

Kontuan izan app-deploy oraindik ez duela erreplikarik definitu.

Hasierako hedapena egitea

Hasierako inplementazioa hasteko, GitlabCI kanalizazioa eskuz abiarazi dezakezu adar maisuan. Horren ostean kubectl honako hau atera beharko luke:

Ikusten dugu app inplementazioa 10 erreplikekin eta app-canary 0rekin. LoadBalancer bat ere badago eta bertatik sar gaitezkeen. curl Kanpoko IP bidez:

while true; do curl -s 35.198.149.232 | grep label; sleep 0.1; done

Gure proba aplikazioak "v1" baino ez duela itzultzen ikusten dugu.

Kanariarren hedapena exekutatzen

1. urratsa: bertsio berri bat kaleratu erabiltzaile batzuentzat

Erreplika kopurua 1ean ezarri dugu deploy-canary.yaml fitxategian eta bertsio berriaren irudian:

kind: Deployment
metadata:
 name: app-canary
spec:
 replicas: 1
 selector:
   matchLabels:
     id: app
     type: canary
 template:
   metadata:
     labels:
       id: app
       type: canary
   spec:
     containers:
     - image: registry.gitlab.com/wuestkamp/k8s-deployment-example-app:v2
       name: app
       resources:
         limits:
           cpu: 100m
           memory: 100Mi

Fitxategian deploy.yaml erreplika kopurua 9ra aldatu dugu:

kind: Deployment
metadata:
 name: app
spec:
 replicas: 9
 selector:
   matchLabels:
     id: app
...

Aldaketa hauek inplementazioa hasiko den biltegira bultzatzen ditugu (GitlabCI bidez) eta ondorioz ikusten dugu:

Gure Zerbitzuak bi inplementazioetara zuzenduko ditu, biek aplikazio-hautatzailea baitute. Kubernetesen aleatorizazio lehenetsia dela eta, erantzun desberdinak ikusi beharko genituzke eskaeren % 10ean:

Gure aplikazioaren egungo egoera (GitOps, Git-etik hartutako egiaren iturri bakarretik hartuta) erreplika aktibo dituzten bi inplementazioren presentzia da, bertsio bakoitzeko bat.

Erabiltzaileen ~% 10 bertsio berri bat ezagutzen da eta nahi gabe probatzen du. Orain da erregistroetan akatsak eta jarraipen-datuetan arazoak aurkitzeko unea.

2. urratsa: kaleratu bertsio berria erabiltzaile guztiei

Dena ondo joan zela erabaki genuen eta orain bertsio berria erabiltzaile guztiei zabaldu behar diegu. Horretarako, eguneratu besterik ez dugu egiten deploy.yaml irudiaren bertsio berri bat instalatzea eta erreplika kopurua berdina 10. In deploy-canary.yaml erreplika kopurua 0ra ezarriko dugu. Inplementatu ondoren, emaitza hau izango da:

Laburbilduz

Niretzat, inplementazioa eskuz exekutatzeak k8s erabiliz zein erraz konfigura daitekeen ulertzen laguntzen du. Kubernetesek API baten bidez dena eguneratzeko aukera ematen dizunez, urrats hauek scripten bidez automatiza daitezke.

Inplementatu behar den beste gauza bat probatzaileen sarrera puntu bat da (LoadBalancer edo Ingress bidez), zeinaren bitartez bertsio berria bakarrik sar daiteke. Eskuzko nabigaziorako erabil daiteke.

Etorkizuneko artikuluetan, egin dugunaren zatirik handiena inplementatzen duten beste irtenbide automatizatu batzuk aztertuko ditugu.

Irakurri beste artikulu batzuk ere gure blogean:

Iturria: www.habr.com

Kanariar inplementazioa Kubernetes #1: Gitlab CI