🥇ಕುಬರ್ನೆಟ್ಸ್ #2 ರಲ್ಲಿ ಕ್ಯಾನರಿ ನಿಯೋಜನೆ: ಅರ್ಗೋ ರೋಲ್‌ಔಟ್ಸ್

ಕುಬರ್ನೆಟ್‌ಗಳಿಗೆ ಕ್ಯಾನರಿ ನಿಯೋಜನೆಗಳನ್ನು ಚಲಾಯಿಸಲು ನಾವು k8s-ಸ್ಥಳೀಯ ಅರ್ಗೋ ರೋಲ್‌ಔಟ್‌ಗಳ ನಿಯೋಜನೆ ನಿಯಂತ್ರಕ ಮತ್ತು GitlabCI ಅನ್ನು ಬಳಸುತ್ತೇವೆ

https://unsplash.com/photos/V41PulGL1z0

ಈ ಸರಣಿಯಲ್ಲಿನ ಲೇಖನಗಳು

ಕುಬರ್ನೆಟ್ಸ್ #1 ರಲ್ಲಿ ಕ್ಯಾನರಿ ನಿಯೋಜನೆ: ಗಿಟ್ಲಾಬ್ CI
(ಈ ಲೇಖನ)
ಇಸ್ಟಿಯೊ ಬಳಸಿ ಕ್ಯಾನರಿ ನಿಯೋಜನೆ
ಜೆಂಕಿನ್ಸ್-ಎಕ್ಸ್ ಇಸ್ಟಿಯೊ ಫ್ಲ್ಯಾಗರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಕ್ಯಾನರಿ ನಿಯೋಜನೆ

ಕ್ಯಾನರಿ ನಿಯೋಜನೆ

ನೀವು ಓದುತ್ತೀರಿ ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ ಮೊದಲ ಭಾಗ, ಅಲ್ಲಿ ನಾವು ಕ್ಯಾನರಿ ನಿಯೋಜನೆಗಳು ಏನೆಂದು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ವಿವರಿಸಿದ್ದೇವೆ. ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಕುಬರ್ನೆಟ್ಸ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅದನ್ನು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು ಎಂಬುದನ್ನು ಸಹ ನಾವು ತೋರಿಸಿದ್ದೇವೆ.

ಅರ್ಗೋ ರೋಲ್ಔಟ್ಗಳು

ಅರ್ಗೋ ರೋಲ್ಔಟ್ಸ್ ಕುಬರ್ನೆಟ್ಸ್ ಸ್ಥಳೀಯ ನಿಯೋಜನೆ ನಿಯಂತ್ರಕವಾಗಿದೆ. ಇದು ಕುಬರ್ನೆಟ್‌ಗಳಿಗೆ CRD (ಕಸ್ಟಮ್ ರಿಸೋರ್ಸ್ ಡೆಫಿನಿಷನ್) ಅನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದಕ್ಕೆ ಧನ್ಯವಾದಗಳು, ನಾವು ಹೊಸ ಘಟಕವನ್ನು ಬಳಸಬಹುದು: Rollout, ಇದು ವಿವಿಧ ಕಾನ್ಫಿಗರೇಶನ್ ಆಯ್ಕೆಗಳೊಂದಿಗೆ ನೀಲಿ-ಹಸಿರು ಮತ್ತು ಕ್ಯಾನರಿ ನಿಯೋಜನೆಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.

ಕಸ್ಟಮ್ ಸಂಪನ್ಮೂಲದಿಂದ ಬಳಸಲಾಗುವ ಅರ್ಗೋ ರೋಲ್‌ಔಟ್‌ಗಳ ನಿಯಂತ್ರಕ Rollout, ಕುಬರ್ನೆಟ್‌ಗಳಿಗೆ ನೀಲಿ-ಹಸಿರು ಮತ್ತು ಕ್ಯಾನರಿಯಂತಹ ಹೆಚ್ಚುವರಿ ನಿಯೋಜನೆ ತಂತ್ರಗಳಿಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಸಂಪನ್ಮೂಲ Rollout ಸಮಾನವಾದ ಕಾರ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ Deployment, ಹೆಚ್ಚುವರಿ ನಿಯೋಜನೆ ತಂತ್ರಗಳೊಂದಿಗೆ ಮಾತ್ರ.
ಸಂಪನ್ಮೂಲ Deployments ನಿಯೋಜನೆಗಾಗಿ ಎರಡು ತಂತ್ರಗಳನ್ನು ಹೊಂದಿದೆ: RollingUpdate и Recreate. ಈ ತಂತ್ರಗಳು ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ಸೂಕ್ತವಾಗಿದ್ದರೂ, ಅತಿ ದೊಡ್ಡ ಪ್ರಮಾಣದಲ್ಲಿ ಸರ್ವರ್‌ಗಳಿಗೆ ನಿಯೋಜನೆಗಾಗಿ, ನಿಯೋಜನೆ ನಿಯಂತ್ರಕದಲ್ಲಿ ಲಭ್ಯವಿಲ್ಲದ ನೀಲಿ-ಹಸಿರು ಅಥವಾ ಕ್ಯಾನರಿಯಂತಹ ಹೆಚ್ಚುವರಿ ತಂತ್ರಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಕುಬರ್ನೆಟ್ಸ್‌ನಲ್ಲಿ ಈ ತಂತ್ರಗಳನ್ನು ಬಳಸಲು, ಬಳಕೆದಾರರು ತಮ್ಮ ನಿಯೋಜನೆಗಳ ಮೇಲೆ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಬರೆಯಬೇಕಾಗಿತ್ತು. Argo Rollouts ನಿಯಂತ್ರಕವು ಈ ತಂತ್ರಗಳನ್ನು ಸರಳ, ಘೋಷಣಾತ್ಮಕ, ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದಾದ ನಿಯತಾಂಕಗಳಾಗಿ ಬಹಿರಂಗಪಡಿಸುತ್ತದೆ.
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

ನಮ್ಮ ಮೂಲಸೌಕರ್ಯ ಟರ್ನಿಪ್‌ನಲ್ಲಿ (ಕೆಳಗೆ ನೋಡಿ) ನಾವು ಈಗಾಗಲೇ install.yaml ಅನ್ನು i/k8s/argo-rollouts/install.yaml ಎಂದು ಸೇರಿಸಿದ್ದೇವೆ. ಈ ರೀತಿಯಲ್ಲಿ GitlabCI ಅದನ್ನು ಕ್ಲಸ್ಟರ್‌ಗೆ ಸ್ಥಾಪಿಸುತ್ತದೆ.

ಕ್ಲೈಂಟ್ ಸೈಡ್ (kubectl ಪ್ಲಗಿನ್)

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

ಉದಾಹರಣೆ ಅಪ್ಲಿಕೇಶನ್

ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ಮತ್ತು ಮೂಲಸೌಕರ್ಯಕ್ಕಾಗಿ ಪ್ರತ್ಯೇಕ ರೆಪೊಸಿಟರಿಗಳನ್ನು ಹೊಂದಲು ಇದು ಉತ್ತಮ ಅಭ್ಯಾಸವಾಗಿದೆ.

ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ರೆಪೊಸಿಟರಿ

Kim Wuestkamp/k8s-deployment-example-app

ಇದು ತುಂಬಾ ಸರಳವಾದ ಪೈಥಾನ್+ಫ್ಲಾಸ್ಕ್ 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 ನಲ್ಲಿ ಎರಡು ಹಂತಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ:

ಕ್ಯಾನರಿಗೆ 10% ಟ್ರಾಫಿಕ್ (ಹಸ್ತಚಾಲಿತ ಸರಿಗಾಗಿ ನಿರೀಕ್ಷಿಸಿ)
ಕ್ಯಾನರಿಗೆ 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 ನೊಂದಿಗೆ ಏಕೀಕರಣವನ್ನು ಪರೀಕ್ಷಿಸಲು ಬಯಸುತ್ತೇನೆ.

ಆದಾಗ್ಯೂ, Argo CI ಮತ್ತು Flux CI ಗಳ ದೊಡ್ಡ ವಿಲೀನವು ಬರುತ್ತಿರುವಂತೆ ತೋರುತ್ತಿದೆ, ಆದ್ದರಿಂದ ಹೊಸ ಬಿಡುಗಡೆಯು ಹೊರಬರುವವರೆಗೆ ನಾನು ಕಾಯಬಹುದು: ಅರ್ಗೋ ಫ್ಲಕ್ಸ್.

ನೀವು Argo Rollouts ಅಥವಾ Argo CI ಯೊಂದಿಗೆ ಯಾವುದೇ ಅನುಭವವನ್ನು ಹೊಂದಿದ್ದೀರಾ?

ನಮ್ಮ ಬ್ಲಾಗ್‌ನಲ್ಲಿ ಇತರ ಲೇಖನಗಳನ್ನು ಸಹ ಓದಿ:

ಮೂಲ: www.habr.com

ಕುಬರ್ನೆಟ್ಸ್ #2 ರಲ್ಲಿ ಕ್ಯಾನರಿ ನಿಯೋಜನೆ: ಅರ್ಗೋ ರೋಲ್ಔಟ್ಸ್