કુબરનેટ્સ #1 માં કેનેરી ડિપ્લોયમેન્ટ: ગિટલેબ સીઆઈ

કુબરનેટ્સમાં કેનેરી ડિપ્લોયમેન્ટનો અમલ કરવા અને ઉપયોગ કરવા માટે અમે Gitlab CI અને મેન્યુઅલ GitOps નો ઉપયોગ કરીશું

આ શ્રેણીમાંથી લેખો:

• (આ લેખ)
• ArgoCI નો ઉપયોગ કરીને કેનેરી જમાવટ
• Istio નો ઉપયોગ કરીને કેનેરી જમાવટ
• જેનકિન્સ-એક્સ ઇસ્ટિઓ ફ્લેગરનો ઉપયોગ કરીને કેનેરી ડિપ્લોયમેન્ટ

અમે GitOps દ્વારા કેનેરી જમાવટ મેન્યુઅલી કરીશું અને મુખ્ય કુબરનેટ્સ સંસાધનો બનાવી/સંશોધિત કરીશું. આ લેખ મુખ્યત્વે પરિચય માટે બનાવાયેલ છે કુબરનેટ્સ કેનેરીમાં જમાવટ કેવી રીતે કાર્ય કરે છે તેની સાથે, કારણ કે ત્યાં ઓટોમેશનની વધુ અસરકારક પદ્ધતિઓ છે, જેને આપણે નીચેના લેખોમાં ધ્યાનમાં લઈશું.

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

કેનેરી જમાવટ

કેનેરી વ્યૂહરચના સાથે, અપડેટ્સ પ્રથમ માત્ર વપરાશકર્તાઓના સબસેટ પર લાગુ થાય છે. મોનિટરિંગ, લોગ ડેટા, મેન્યુઅલ ટેસ્ટિંગ અથવા અન્ય પ્રતિસાદ ચેનલો દ્વારા, બધા વપરાશકર્તાઓ માટે રિલીઝ થાય તે પહેલાં તેનું પરીક્ષણ કરવામાં આવે છે.

કુબરનેટ્સ જમાવટ (રોલિંગ અપડેટ)

કુબરનેટ્સ ડિપ્લોયમેન્ટ માટેની ડિફોલ્ટ વ્યૂહરચના રોલિંગ-અપડેટ છે, જ્યાં ચોક્કસ સંખ્યામાં પોડ્સ ઈમેજોના નવા વર્ઝન સાથે લોન્ચ કરવામાં આવે છે. જો તેઓ સમસ્યાઓ વિના બનાવવામાં આવ્યા હોય, તો છબીઓના જૂના સંસ્કરણો સાથેના શીંગો સમાપ્ત થાય છે, અને નવા શીંગો સમાંતર બનાવવામાં આવે છે.

ગીટોપ્સ

અમે આ ઉદાહરણમાં GitOps નો ઉપયોગ કરીએ છીએ કારણ કે અમે:

• સત્યના એક સ્ત્રોત તરીકે ગિટનો ઉપયોગ
• અમે બિલ્ડ અને જમાવટ માટે ગિટ ઑપરેશન્સનો ઉપયોગ કરીએ છીએ (ગિટ ટૅગ/મર્જ સિવાયના કોઈ આદેશોની જરૂર નથી)

ઉદાહરણ:

ચાલો એક સારી પ્રેક્ટિસ કરીએ - એપ્લિકેશન કોડ માટે એક ભંડાર અને એક ઈન્ફ્રાસ્ટ્રક્ચર માટે.

એપ્લિકેશન ભંડાર

આ એક ખૂબ જ સરળ Python+Flask API છે જે JSON તરીકે પ્રતિસાદ આપે છે. અમે GitlabCI મારફતે પેકેજ બનાવીશું અને પરિણામને Gitlab રજિસ્ટ્રીમાં મોકલીશું. રજિસ્ટ્રીમાં અમારી પાસે બે અલગ અલગ પ્રકાશન સંસ્કરણો છે:

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

તેમની વચ્ચેનો એક માત્ર તફાવત એ પરત કરેલી JSON ફાઇલમાં ફેરફાર છે. અમે આ એપ્લિકેશનનો ઉપયોગ શક્ય તેટલી સરળતાથી કલ્પના કરવા માટે કરીએ છીએ કે અમે કયા સંસ્કરણ સાથે વાતચીત કરી રહ્યા છીએ.

ઇન્ફ્રાસ્ટ્રક્ચર ભંડાર

આ સલગમમાં અમે GitlabCI મારફતે કુબરનેટ્સ સુધી જમાવશું, .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, સત્યના સિંગલ સ્ત્રોત તરીકે ગિટમાંથી લેવામાં આવેલ) એ સક્રિય પ્રતિકૃતિઓ સાથે બે જમાવટની હાજરી છે, દરેક સંસ્કરણ માટે એક.

~10% વપરાશકર્તાઓ નવા સંસ્કરણથી પરિચિત થાય છે અને અજાણતાં તેનું પરીક્ષણ કરે છે. સમસ્યાઓ શોધવા માટે લોગ અને મોનિટરિંગ ડેટામાં ભૂલો માટે તપાસ કરવાનો હવે સમય છે.

પગલું 2: બધા વપરાશકર્તાઓ માટે નવું સંસ્કરણ પ્રકાશિત કરો

અમે નક્કી કર્યું છે કે બધું બરાબર થઈ ગયું છે અને હવે અમારે બધા વપરાશકર્તાઓ માટે નવું સંસ્કરણ રજૂ કરવાની જરૂર છે. આ કરવા માટે અમે ફક્ત અપડેટ કરીએ છીએ deploy.yaml ઇમેજનું નવું વર્ઝન ઇન્સ્ટોલ કરવું અને 10 જેટલી પ્રતિકૃતિઓની સંખ્યા deploy-canary.yaml અમે પ્રતિકૃતિઓની સંખ્યા 0 પર સેટ કરીએ છીએ. જમાવટ પછી, પરિણામ નીચે મુજબ હશે:

અપ સમજી

મારા માટે, આ રીતે ડિપ્લોયમેન્ટને મેન્યુઅલી ચલાવવું એ સમજવામાં મદદ કરે છે કે તે k8s નો ઉપયોગ કરીને કેટલી સરળતાથી ગોઠવી શકાય છે. કુબરનેટ્સ તમને API દ્વારા બધું અપડેટ કરવાની મંજૂરી આપે છે, તેથી આ પગલાંઓ સ્ક્રિપ્ટ્સ દ્વારા સ્વચાલિત થઈ શકે છે.

બીજી વસ્તુ કે જેને અમલમાં મૂકવાની જરૂર છે તે છે ટેસ્ટર એન્ટ્રી પોઈન્ટ (લોડબેલેન્સર અથવા ઇન્ગ્રેસ દ્વારા) જેના દ્વારા ફક્ત નવા સંસ્કરણને જ એક્સેસ કરી શકાય છે. તેનો ઉપયોગ મેન્યુઅલ બ્રાઉઝિંગ માટે કરી શકાય છે.

ભવિષ્યના લેખોમાં, અમે અન્ય સ્વયંસંચાલિત ઉકેલો તપાસીશું જે અમે જે કર્યું છે તેમાંથી મોટા ભાગનો અમલ કરે છે.

અમારા બ્લોગ પર અન્ય લેખો પણ વાંચો:

• અધિકૃતતા સાથે ક્લિકહાઉસમાંથી અધિકૃતતા વિના ક્લિકહાઉસમાં સ્થાનાંતરણ શું તરફ દોરી ગયું?
• Nginx માટે ડાયનેમિક મોડ્યુલ બનાવવું
• અપડેટ કરો nxs-build-tools - deb અને rpm પેકેજો બનાવવા માટે સહાયક
• હાશિકોર્પ કોન્સ્યુલના કુબરનેટ્સ ઓથોરાઇઝેશનનો પરિચય
• Csync2 ઉપયોગિતાનો ઉપયોગ કરતી વખતે અમારે શું સામનો કરવો પડ્યો હતો
• રેડમાઇન માટે ટેલિગ્રામ બોટ. તમારા અને અન્ય લોકો માટે જીવન કેવી રીતે સરળ બનાવવું

સોર્સ: www.habr.com