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

અમે k8s-નેટિવ આર્ગો રોલઆઉટ ડિપ્લોયમેન્ટ કંટ્રોલર અને GitlabCI નો ઉપયોગ કુબરનેટ્સ પર કેનેરી ડિપ્લોયમેન્ટ ચલાવવા માટે કરીશું.

https://unsplash.com/photos/V41PulGL1z0

આ શ્રેણીના લેખો

• કુબરનેટ્સ #1 માં કેનેરી ડિપ્લોયમેન્ટ: ગિટલેબ સીઆઈ
• (આ લેખ)
• Istio નો ઉપયોગ કરીને કેનેરી જમાવટ
• જેનકિન્સ-એક્સ ઇસ્ટિઓ ફ્લેગરનો ઉપયોગ કરીને કેનેરી ડિપ્લોયમેન્ટ

કેનેરી જમાવટ

અમને આશા છે કે તમે વાંચશો પ્રથમ ભાગ, જ્યાં અમે ટૂંકમાં સમજાવ્યું કે કેનેરી ડિપ્લોયમેન્ટ્સ શું છે. અમે પ્રમાણભૂત Kubernetes સંસાધનોનો ઉપયોગ કરીને તેનો અમલ કેવી રીતે કરવો તે પણ બતાવ્યું.

આર્ગો રોલઆઉટ્સ

Argo Rollouts એ Kubernetes નેટીવ ડિપ્લોયમેન્ટ કંટ્રોલર છે. તે કુબરનેટ્સ માટે CRD (કસ્ટમ રિસોર્સ ડેફિનેશન) પ્રદાન કરે છે. તેના માટે આભાર, અમે એક નવી એન્ટિટીનો ઉપયોગ કરી શકીએ છીએ: Rollout, જે વિવિધ રૂપરેખાંકન વિકલ્પો સાથે વાદળી-લીલા અને કેનેરી જમાવટનું સંચાલન કરે છે.

કસ્ટમ સંસાધન દ્વારા ઉપયોગમાં લેવાતા આર્ગો રોલઆઉટ્સ કંટ્રોલર Rollout, કુબરનેટ્સ માટે બ્લુ-ગ્રીન અને કેનેરી જેવી વધારાની ડિપ્લોયમેન્ટ વ્યૂહરચનાઓ માટે પરવાનગી આપે છે. સંસાધન Rollout કાર્યક્ષમતા સમકક્ષ પ્રદાન કરે છે Deployment, માત્ર વધારાની જમાવટ વ્યૂહરચના સાથે.
રિસોર્સ Deployments જમાવટ માટે બે વ્યૂહરચના છે: RollingUpdate и Recreate. જો કે આ વ્યૂહરચના મોટા ભાગના કિસ્સાઓમાં યોગ્ય છે, સર્વર પર ખૂબ મોટા પાયા પર જમાવટ માટે, વધારાની વ્યૂહરચનાઓનો ઉપયોગ કરવામાં આવે છે, જેમ કે વાદળી-લીલો અથવા કેનેરી, જે ડિપ્લોયમેન્ટ કંટ્રોલરમાં ઉપલબ્ધ નથી. કુબરનેટ્સમાં આ વ્યૂહરચનાઓનો ઉપયોગ કરવા માટે, વપરાશકર્તાઓએ તેમના જમાવટની ટોચ પર સ્ક્રિપ્ટો લખવાની હતી. આર્ગો રોલઆઉટ્સ કંટ્રોલર આ વ્યૂહરચનાઓને સરળ, ઘોષણાત્મક, રૂપરેખાંકિત પરિમાણો તરીકે ઉજાગર કરે છે.
https://argoproj.github.io/argo-rollouts

અર્ગો સીઆઈ પણ છે, જે રોલઆઉટ્સ સાથે વાપરવા માટે અનુકૂળ વેબ ઈન્ટરફેસ પૂરું પાડે છે, અમે તેના પર આગામી લેખમાં એક નજર નાખીશું.

આર્ગો રોલઆઉટ્સ ઇન્સ્ટોલ કરી રહ્યું છે

સર્વર બાજુ

kubectl create namespace argo-rolloutskubectl apply -n argo-rollouts -f https://raw.githubusercontent.com/argoproj/argo-rollouts/stable/manifests/install.yaml

અમારા ઈન્ફ્રાસ્ટ્રક્ચર સલગમમાં (નીચે જુઓ) અમે પહેલેથી જ i/k8s/argo-rollouts/install.yaml તરીકે install.yaml ઉમેર્યું છે. આ રીતે GitlabCI તેને ક્લસ્ટરમાં ઇન્સ્ટોલ કરશે.

ક્લાયન્ટ બાજુ (kubectl પ્લગઇન)

https://argoproj.github.io/argo-rollouts/features/kubectl-plugin

ઉદાહરણ એપ્લિકેશન

એપ્લીકેશન કોડ અને ઈન્ફ્રાસ્ટ્રક્ચર માટે અલગ રીપોઝીટરી હોવી સારી પ્રથા છે.

એપ્લિકેશન માટે રીપોઝીટરી

Kim Wuestkamp/k8s-deployment-example-app

આ એક ખૂબ જ સરળ 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-dockerbefore_script:
   - printenv
   - kubectl versionstages:
 - deploydeploy 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: rollout-canary
 name: app
spec:
 ports:
 - port: 80
   protocol: TCP
   targetPort: 5000
 selector:
   id: app
 type: LoadBalancer

અને rollout.yaml :

apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
 name: rollout-canary
spec:
 replicas: 10
 revisionHistoryLimit: 2
 selector:
   matchLabels:
     id: rollout-canary
 template:
   metadata:
     labels:
       id: rollout-canary
   spec:
     containers:
     - name: rollouts-demo
       image: registry.gitlab.com/wuestkamp/k8s-deployment-example-app:v1
       imagePullPolicy: Always
 strategy:
   canary:
     steps:
     - setWeight: 10
     # Rollouts can be manually resumed by running `kubectl argo rollouts promote ROLLOUT`
     - pause: {}
     - setWeight: 50
     - pause: { duration: 120 } # two minutes

Rollout ડિપ્લોયમેન્ટની જેમ જ કામ કરે છે. જો આપણે અપડેટ વ્યૂહરચના સેટ ન કરીએ (જેમ કે કેનેરી અહીં) તે ડિફોલ્ટ રોલિંગ-અપડેટ ડિપ્લોયમેન્ટની જેમ વર્તે છે.

કેનેરી જમાવટ માટે અમે yaml માં બે પગલાં વ્યાખ્યાયિત કરીએ છીએ:

1. કેનેરી તરફનો 10% ટ્રાફિક (મેન્યુઅલ ઓકે માટે રાહ જુઓ)
2. કેનેરી તરફ 50% ટ્રાફિક (2 મિનિટ રાહ જુઓ પછી 100% સુધી ચાલુ રાખો)

પ્રારંભિક જમાવટ કરી રહ્યા છીએ

પ્રારંભિક જમાવટ પછી, અમારા સંસાધનો આના જેવા દેખાશે:

અને અમને એપ્લિકેશનના પ્રથમ સંસ્કરણમાંથી જ પ્રતિસાદ મળે છે:

કેનેરી જમાવટ કરી રહ્યા છીએ

પગલું 1: 10% ટ્રાફિક

કેનેરી જમાવટ શરૂ કરવા માટે, અમારે ફક્ત ઇમેજ સંસ્કરણ બદલવાની જરૂર છે જેમ કે અમે સામાન્ય રીતે જમાવટ સાથે કરીએ છીએ:

apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
 name: rollout-canary
spec:
...
 template:
   metadata:
     labels:
       id: rollout-canary
   spec:
     containers:
     - name: rollouts-demo
       image: registry.gitlab.com/wuestkamp/k8s-deployment-example-app:v2
...

અને અમે ફેરફારોને આગળ ધપાવીએ છીએ, તેથી Gitlab CI તૈનાત કરે છે અને અમે ફેરફારો જોઈએ છીએ:

હવે જો આપણે સેવાને ઍક્સેસ કરીએ:

મહાન! અમે અમારા કેનેરી જમાવટની મધ્યમાં છીએ. આપણે દોડીને પ્રગતિ જોઈ શકીએ છીએ:

kubectl argo rollouts get rollout rollout-canary

પગલું 2: 50% ટ્રાફિક:

હવે ચાલો આગલા પગલા પર આગળ વધીએ: 50% ટ્રાફિકને રીડાયરેક્ટ કરવું. અમે આ પગલું જાતે ચલાવવા માટે ગોઠવ્યું છે:

kubectl argo rollouts promote rollout-canary # continue to step 2

અને અમારી એપ્લિકેશન નવા સંસ્કરણોમાંથી 50% પ્રતિસાદો પરત કરે છે:

અને રોલઆઉટ સમીક્ષા:

અદ્ભુત.

પગલું 3: 100% ટ્રાફિક:

અમે તેને સેટ કરીએ છીએ જેથી 2 મિનિટ પછી 50% પગલું આપમેળે સમાપ્ત થાય અને 100% પગલું શરૂ થાય:

અને એપ્લિકેશન આઉટપુટ:

અને રોલઆઉટ સમીક્ષા:

કેનેરી જમાવટ પૂર્ણ છે.

આર્ગો રોલઆઉટ્સ સાથે વધુ ઉદાહરણો

અહીં વધુ ઉદાહરણો છે, જેમ કે કેનેરી પર આધારિત પર્યાવરણ પૂર્વાવલોકનો અને સરખામણીઓ કેવી રીતે સેટ કરવી:

https://github.com/argoproj/argo-rollouts/tree/master/examples

આર્ગો રોલઆઉટ્સ અને આર્ગો સીઆઈ વિશે વિડિઓ

હું ખરેખર આ વિડિઓની ભલામણ કરું છું, તે બતાવે છે કે Argo Rollouts અને Argo CI એકસાથે કેવી રીતે કામ કરે છે:

પરિણામ

મને CRD નો ઉપયોગ કરવાનો વિચાર ખરેખર ગમે છે જે વધારાના પ્રકારનાં જમાવટ અથવા પ્રતિકૃતિઓ, રીડાયરેક્ટ ટ્રાફિક વગેરેનું સંચાલન કરે છે. તેમની સાથે કામ સરળતાથી ચાલે છે. આગળ હું આર્ગો સીઆઈ સાથે એકીકરણનું પરીક્ષણ કરવા માંગુ છું.

જો કે, Argo CI અને Flux CIનું મોટું મર્જર આવી રહ્યું હોય તેવું લાગે છે, તેથી હું નવી રીલીઝ બહાર ન આવે ત્યાં સુધી રાહ જોઈ શકું છું: આર્ગો ફ્લક્સ.

શું તમને Argo Rollouts અથવા Argo CI નો કોઈ અનુભવ છે?

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

• Nginx વેબ સર્વર સાથે વસંત એપ્લિકેશનોની બ્લુ-ગ્રીન ડિપ્લોયમેન્ટ
• કુબરનેટ્સ: સિસ્ટમ રિસોર્સ મેનેજમેન્ટને ગોઠવવું શા માટે એટલું મહત્વપૂર્ણ છે?
• હાશિકોર્પ કોન્સ્યુલના કુબરનેટ્સ ઓથોરાઇઝેશનનો પરિચય
• ટેકટન પાઈપલાઈન - કુબરનેટસ-નેટિવ પાઈપલાઈન
• Nginx માટે ડાયનેમિક મોડ્યુલ બનાવવું
• રેડમાઇન માટે ટેલિગ્રામ બોટ. તમારા અને અન્ય લોકો માટે જીવન કેવી રીતે સરળ બનાવવું

સોર્સ: www.habr.com