కుబెర్నెట్స్ #1లో కానరీ విస్తరణ: గిట్లాబ్ CI

మేము కుబెర్నెట్స్‌లో కానరీ విస్తరణను అమలు చేయడానికి మరియు ఉపయోగించడానికి Gitlab CI మరియు మాన్యువల్ GitOpsని ఉపయోగిస్తాము

ఈ సిరీస్ నుండి కథనాలు:

• (ఈ వ్యాసం)
• ArgoCI ఉపయోగించి కానరీ విస్తరణ
• Istio ఉపయోగించి కానరీ విస్తరణ
• జెంకిన్స్-ఎక్స్ ఇస్టియో ఫ్లాగర్ ఉపయోగించి కానరీ విస్తరణ

మేము GitOps ద్వారా మాన్యువల్‌గా కానరీ విస్తరణను నిర్వహిస్తాము మరియు ప్రధాన కుబెర్నెట్స్ వనరులను సృష్టిస్తాము/సవరిస్తాము. ఈ వ్యాసం ప్రధానంగా పరిచయం కోసం ఉద్దేశించబడింది కుబెర్నెటెస్ కానరీలో విస్తరణ ఎలా పని చేస్తుందో, ఆటోమేషన్ యొక్క మరింత ప్రభావవంతమైన పద్ధతులు ఉన్నందున, మేము ఈ క్రింది కథనాలలో పరిశీలిస్తాము.

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

కానరీ విస్తరణ

కానరీ వ్యూహంతో, నవీకరణలు మొదట వినియోగదారుల ఉపసమితికి మాత్రమే వర్తింపజేయబడతాయి. పర్యవేక్షణ, లాగ్ డేటా, మాన్యువల్ టెస్టింగ్ లేదా ఇతర ఫీడ్‌బ్యాక్ ఛానెల్‌ల ద్వారా, విడుదల వినియోగదారులందరికీ విడుదల చేయడానికి ముందే పరీక్షించబడుతుంది.

కుబెర్నెట్స్ విస్తరణ (రోలింగ్ అప్‌డేట్)

కుబెర్నెటెస్ డిప్లాయ్‌మెంట్ కోసం డిఫాల్ట్ వ్యూహం రోలింగ్-అప్‌డేట్, ఇక్కడ నిర్దిష్ట సంఖ్యలో పాడ్‌లు చిత్రాల కొత్త వెర్షన్‌లతో ప్రారంభించబడతాయి. అవి సమస్యలు లేకుండా సృష్టించబడితే, పాత వెర్షన్ చిత్రాలతో పాడ్‌లు నిలిపివేయబడతాయి మరియు కొత్త పాడ్‌లు సమాంతరంగా సృష్టించబడతాయి.

GitOps

మేము ఈ ఉదాహరణలో GitOpsని ఉపయోగిస్తాము ఎందుకంటే మేము:

• సత్యం యొక్క ఒకే మూలంగా Gitని ఉపయోగించడం
• మేము బిల్డ్ మరియు డిప్లాయ్‌మెంట్ కోసం Git ఆపరేషన్‌లను ఉపయోగిస్తాము (git tag/merge తప్ప ఇతర ఆదేశాలు అవసరం లేదు)

ఉదాహరణకు

అప్లికేషన్ కోడ్ కోసం ఒక రిపోజిటరీ మరియు ఇన్‌ఫ్రాస్ట్రక్చర్ కోసం ఒక రిపోజిటరీని కలిగి ఉండటానికి మంచి అభ్యాసాన్ని తీసుకుందాం.

అప్లికేషన్ రిపోజిటరీ

ఇది చాలా సులభమైన పైథాన్+ఫ్లాస్క్ API, ఇది JSONగా ప్రతిస్పందనను అందిస్తుంది. మేము GitlabCI ద్వారా ప్యాకేజీని నిర్మిస్తాము మరియు ఫలితాన్ని Gitlab రిజిస్ట్రీకి పుష్ చేస్తాము. రిజిస్ట్రీలో మనకు రెండు వేర్వేరు విడుదల వెర్షన్లు ఉన్నాయి:

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

తిరిగి వచ్చిన JSON ఫైల్‌లో మార్పు మాత్రమే వాటి మధ్య తేడా. మేము ఏ వెర్షన్‌తో కమ్యూనికేట్ చేస్తున్నామో వీలైనంత సులభంగా విజువలైజ్ చేయడానికి ఈ అప్లికేషన్‌ని ఉపయోగిస్తాము.

ఇన్‌ఫ్రాస్ట్రక్చర్ రిపోజిటరీ

ఈ టర్నిప్‌లో మేము గిట్లాబ్‌సిఐ ద్వారా కుబెర్నెట్స్‌కు పంపిస్తాము, .gitlab-ci.yml ఇలా ఉంది:

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

దీన్ని మీరే అమలు చేయడానికి మీకు క్లస్టర్ అవసరం, మీరు Gcloudని ఉపయోగించవచ్చు:

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

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

మీరు ఫోర్క్ చేయాలి https://gitlab.com/wuestkamp/k8s-deployment-example-canary-infrastructure మరియు వేరియబుల్ సృష్టించండి KUBECONFIG GitlabCIలో, యాక్సెస్ కోసం కాన్ఫిగర్ ఉంటుంది kubectl మీ క్లస్టర్‌కి.

క్లస్టర్ (Gcloud) కోసం ఆధారాలను ఎలా పొందాలో మీరు చదువుకోవచ్చు ఇక్కడే.

ఇన్ఫ్రాస్ట్రక్చర్ Yaml

ఇన్‌ఫ్రాస్ట్రక్చర్ రిపోజిటరీలో మాకు సేవ ఉంది:

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

మరియు విస్తరణ 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

మరియు మరొక విస్తరణ 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

యాప్-డిప్లాయ్‌లో ఇంకా ఏ ప్రతిరూపాలు నిర్వచించబడలేదని గమనించండి.

ప్రారంభ విస్తరణను నిర్వహిస్తోంది

ప్రారంభ విస్తరణను ప్రారంభించడానికి, మీరు మాస్టర్ బ్రాంచ్‌లో GitlabCI పైప్‌లైన్‌ను మాన్యువల్‌గా ప్రారంభించవచ్చు. దాని తరువాత kubectl కింది వాటిని అవుట్‌పుట్ చేయాలి:

మేము చూసాము app 10 ప్రతిరూపాలతో విస్తరణ మరియు 0తో యాప్-కానరీ. మేము యాక్సెస్ చేయగల లోడ్‌బ్యాలెన్సర్ కూడా ఉంది. curl బాహ్య IP ద్వారా:

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

మా పరీక్ష అప్లికేషన్ “v1”ని మాత్రమే అందిస్తుంది.

కానరీ విస్తరణను అమలు చేస్తోంది

దశ 1: కొంతమంది వినియోగదారుల కోసం కొత్త వెర్షన్‌ను విడుదల చేయండి

మేము deploy-canary.yaml ఫైల్ మరియు కొత్త వెర్షన్ ఇమేజ్‌లో ప్రతిరూపాల సంఖ్యను 1కి సెట్ చేసాము:

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

ఫైల్‌లో deploy.yaml మేము ప్రతిరూపాల సంఖ్యను 9కి మార్చాము:

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

మేము ఈ మార్పులను డిప్లాయ్‌మెంట్ ప్రారంభమయ్యే రిపోజిటరీకి పంపుతాము (GitlabCI ద్వారా) మరియు ఫలితంగా చూస్తాము:

మా సేవ రెండు డిప్లాయ్‌మెంట్‌లను సూచిస్తుంది, ఎందుకంటే రెండింటికీ యాప్ సెలెక్టర్ ఉంది. కుబెర్నెటీస్ డిఫాల్ట్ రాండమైజేషన్ కారణంగా, మేము ~10% అభ్యర్థనలకు భిన్నమైన ప్రతిస్పందనలను చూస్తాము:

మా అప్లికేషన్ యొక్క ప్రస్తుత స్థితి (GitOps, Git నుండి సత్యానికి ఒకే మూలంగా తీసుకోబడింది) అనేది సక్రియ ప్రతిరూపాలతో రెండు విస్తరణలు, ప్రతి సంస్కరణకు ఒకటి.

~10% వినియోగదారులు కొత్త వెర్షన్‌తో సుపరిచితులయ్యారు మరియు అనుకోకుండా దాన్ని పరీక్షించారు. సమస్యలను కనుగొనడానికి లాగ్‌లు మరియు పర్యవేక్షణ డేటాలోని లోపాలను తనిఖీ చేయడానికి ఇప్పుడు సమయం ఆసన్నమైంది.

దశ 2: వినియోగదారులందరికీ కొత్త వెర్షన్‌ను విడుదల చేయండి

మేము ప్రతిదీ సరిగ్గా జరిగిందని నిర్ణయించుకున్నాము మరియు ఇప్పుడు మేము వినియోగదారులందరికీ కొత్త సంస్కరణను అందించాలి. దీన్ని చేయడానికి మేము కేవలం అప్డేట్ చేస్తాము deploy.yaml చిత్రం యొక్క కొత్త సంస్కరణను ఇన్‌స్టాల్ చేస్తోంది మరియు 10కి సమానమైన ప్రతిరూపాల సంఖ్య deploy-canary.yaml మేము ప్రతిరూపాల సంఖ్యను తిరిగి 0కి సెట్ చేసాము. విస్తరణ తర్వాత, ఫలితం క్రింది విధంగా ఉంటుంది:

సంగ్రహించేందుకు

నా కోసం, ఈ విధంగా డిప్లాయ్‌మెంట్‌ను మాన్యువల్‌గా అమలు చేయడం k8sని ఉపయోగించి ఎంత సులభంగా కాన్ఫిగర్ చేయవచ్చో అర్థం చేసుకోవడానికి సహాయపడుతుంది. API ద్వారా ప్రతిదాన్ని అప్‌డేట్ చేయడానికి Kubernetes మిమ్మల్ని అనుమతిస్తుంది కాబట్టి, ఈ దశలను స్క్రిప్ట్‌ల ద్వారా ఆటోమేట్ చేయవచ్చు.

అమలు చేయవలసిన మరొక విషయం టెస్టర్ ఎంట్రీ పాయింట్ (లోడ్‌బ్యాలెన్సర్ లేదా ఇన్‌గ్రెస్ ద్వారా) దీని ద్వారా కొత్త వెర్షన్‌ను మాత్రమే యాక్సెస్ చేయవచ్చు. ఇది మాన్యువల్ బ్రౌజింగ్ కోసం ఉపయోగించవచ్చు.

భవిష్యత్ కథనాలలో, మేము చేసిన వాటిలో చాలా వరకు అమలు చేసే ఇతర స్వయంచాలక పరిష్కారాలను మేము పరిశీలిస్తాము.

మా బ్లాగ్‌లోని ఇతర కథనాలను కూడా చదవండి:

• అనుమతి లేకుండా ClickHouse నుండి ఆథరైజేషన్ ఉన్న ClickHouseకి వలసలు దేనికి దారితీశాయి?
• Nginx కోసం డైనమిక్ మాడ్యూల్‌లను నిర్మించడం
• nxs-build-toolsని నవీకరించండి - deb మరియు rpm ప్యాకేజీలను నిర్మించడంలో సహాయకుడు
• హాషికార్ప్ కాన్సుల్ యొక్క కుబెర్నెట్స్ ఆథరైజేషన్ పరిచయం
• Csync2 యుటిలిటీని ఉపయోగిస్తున్నప్పుడు మనం ఏమి ఎదుర్కోవాల్సి వచ్చింది
• Redmine కోసం టెలిగ్రామ్ బాట్. మీ కోసం మరియు ఇతరుల కోసం జీవితాన్ని ఎలా సరళీకృతం చేయాలి

మూలం: www.habr.com