ავტომატური კანარის განლაგება Flagger-ით და Istio-ით

CD აღიარებულია, როგორც საწარმოს პროგრამული უზრუნველყოფის პრაქტიკა და არის დადგენილი CI პრინციპების ბუნებრივი ევოლუციის შედეგი. თუმცა, CD ჯერ კიდევ საკმაოდ იშვიათია, ალბათ მენეჯმენტის სირთულისა და წარუმატებელი განლაგების შიშის გამო, რომელიც გავლენას მოახდენს სისტემის ხელმისაწვდომობაზე.

დროშავი არის ღია კოდის Kubernetes ოპერატორი, რომელიც მიზნად ისახავს გაუგებარი ურთიერთობების აღმოფხვრას. ის ავტომატიზირებს კანარის განლაგების პოპულარიზაციას Istio ტრაფიკის ოფსეტისა და პრომეთეუსის მეტრიკის გამოყენებით აპლიკაციის ქცევის გასაანალიზებლად მართული გაშვების დროს.

ქვემოთ მოცემულია ნაბიჯ-ნაბიჯ სახელმძღვანელო, რათა დააყენოთ და გამოიყენოთ Flagger Google Kubernetes Engine-ზე (GKE).

Kubernetes კლასტერის დაყენება

თქვენ იწყებთ GKE კლასტერის შექმნით Istio დანამატით (თუ არ გაქვთ GCP ანგარიში, შეგიძლიათ დარეგისტრირდეთ აქ - უფასო კრედიტების მისაღებად).

შედით Google Cloud-ში, შექმენით პროექტი და ჩართეთ ბილინგი. დააინსტალირეთ ბრძანების ხაზის პროგრამა gcloud და დააყენეთ თქვენი პროექტი gcloud init.

დააყენეთ ნაგულისხმევი პროექტი, გამოთვალეთ ფართობი და ზონა (ჩანაცვლება PROJECT_ID თქვენი პროექტისთვის):

gcloud config set project PROJECT_ID
gcloud config set compute/region us-central1
gcloud config set compute/zone us-central1-a

ჩართეთ GKE სერვისი და შექმენით კლასტერი HPA და Istio დანამატებით:

gcloud services enable container.googleapis.com
K8S_VERSION=$(gcloud beta container get-server-config --format=json | jq -r '.validMasterVersions[0]')
gcloud beta container clusters create istio 
--cluster-version=${K8S_VERSION} 
--zone=us-central1-a 
--num-nodes=2 
--machine-type=n1-standard-2 
--disk-size=30 
--enable-autorepair 
--no-enable-cloud-logging 
--no-enable-cloud-monitoring 
--addons=HorizontalPodAutoscaling,Istio 
--istio-config=auth=MTLS_PERMISSIVE

ზემოაღნიშნული ბრძანება შექმნის ნაგულისხმევი კვანძის აუზს ორი VM-ის ჩათვლით n1-standard-2 (vCPU: 2, ოპერატიული მეხსიერება 7,5 GB, დისკი: 30 GB). იდეალურ შემთხვევაში, თქვენ უნდა გამოყოთ Istio კომპონენტები თქვენი დატვირთვისგან, მაგრამ არ არსებობს მარტივი გზა Istio Pods-ის გასაშვებად კვანძების სპეციალურ აუზში. Istio მანიფესტები განიხილება მხოლოდ წაკითხვად და GKE გააუქმებს ნებისმიერ ცვლილებას, როგორიცაა კვანძთან დაკავშირება ან პოდიდან გამოყოფა.

დააყენეთ რწმუნებათა სიგელები kubectl:

gcloud container clusters get-credentials istio

შექმენით კლასტერის ადმინისტრატორის როლის სავალდებულო:

kubectl create clusterrolebinding "cluster-admin-$(whoami)" 
--clusterrole=cluster-admin 
--user="$(gcloud config get-value core/account)"

დააინსტალირეთ ბრძანების ხაზის ინსტრუმენტი საჭესთან:

brew install kubernetes-helm

Homebrew 2.0 ახლა ასევე ხელმისაწვდომია Linux.

შექმენით სერვისის ანგარიში და კლასტერული როლის სავალდებულო Tiller-ისთვის:

kubectl -n kube-system create sa tiller && 
kubectl create clusterrolebinding tiller-cluster-rule 
--clusterrole=cluster-admin 
--serviceaccount=kube-system:tiller

გააფართოვეთ Tiller სახელთა სივრცეში kube-system:

helm init --service-account tiller

თქვენ უნდა განიხილოთ SSL-ის გამოყენება Helm-სა და Tiller-ს შორის. თქვენი ჩაფხუტის ინსტალაციის დაცვის შესახებ დამატებითი ინფორმაციისთვის იხილეთ docs.helm.sh

დაადასტურეთ პარამეტრები:

kubectl -n istio-system get svc

რამდენიმე წამის შემდეგ, GCP-მა უნდა მიანიჭოს გარე IP მისამართი სერვისს istio-ingressgateway.

Istio Ingress Gateway-ის კონფიგურაცია

შექმენით სტატიკური IP მისამართი სახელით istio-gatewayIstio კარიბჭის IP მისამართის გამოყენებით:

export GATEWAY_IP=$(kubectl -n istio-system get svc/istio-ingressgateway -ojson | jq -r .status.loadBalancer.ingress[0].ip)
gcloud compute addresses create istio-gateway --addresses ${GATEWAY_IP} --region us-central1

ახლა თქვენ გჭირდებათ ინტერნეტ დომენი და წვდომა თქვენს DNS რეგისტრატორზე. დაამატეთ ორი A ჩანაწერი (შეცვალეთ example.com თქვენს დომენზე):

istio.example.com   A ${GATEWAY_IP}
*.istio.example.com A ${GATEWAY_IP}

დაადასტურეთ, რომ DNS wildcard მუშაობს:

watch host test.istio.example.com

შექმენით ზოგადი Istio კარიბჭე სერვისების მიწოდებისთვის სერვისის ქსელის მიღმა HTTP-ით:

apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: public-gateway
  namespace: istio-system
spec:
  selector:
    istio: ingressgateway
  servers:
    - port:
        number: 80
        name: http
        protocol: HTTP
      hosts:
        - "*"

შეინახეთ ზემოაღნიშნული რესურსი, როგორც public-gateway.yaml და შემდეგ გამოიყენეთ იგი:

kubectl apply -f ./public-gateway.yaml

არცერთ საწარმოო სისტემამ არ უნდა უზრუნველყოს სერვისები ინტერნეტში SSL-ის გარეშე. Istio-ს შესასვლელი კარიბჭის უზრუნველსაყოფად სერტიფიკატის მენეჯერის, CloudDNS-ისა და Let's Encrypt-ით, გთხოვთ, წაიკითხოთ დოკუმენტაცია დროშა გ.კ.ე.

Flagger-ის ინსტალაცია

GKE Istio დანამატი არ შეიცავს პრომეთეს მაგალითს, რომელიც ასუფთავებს Istio ტელემეტრიის სერვისს. იმის გამო, რომ Flagger იყენებს Istio HTTP მეტრიკას კანარის ანალიზის შესასრულებლად, თქვენ უნდა განათავსოთ შემდეგი Prometheus კონფიგურაცია, მსგავსი, რომელიც მოყვება ოფიციალურ Istio Helm სქემას.

REPO=https://raw.githubusercontent.com/stefanprodan/flagger/master
kubectl apply -f ${REPO}/artifacts/gke/istio-prometheus.yaml

დაამატეთ Flagger Helm საცავი:

helm repo add flagger [https://flagger.app](https://flagger.app/)

გააფართოვეთ Flagger სახელთა სივრცეში istio-systemSlack შეტყობინებების ჩართვით:

helm upgrade -i flagger flagger/flagger 
--namespace=istio-system 
--set metricsServer=http://prometheus.istio-system:9090 
--set slack.url=https://hooks.slack.com/services/YOUR-WEBHOOK-ID 
--set slack.channel=general 
--set slack.user=flagger

შეგიძლიათ დააინსტალიროთ Flagger ნებისმიერ სახელთა სივრცეში, სანამ მას შეუძლია დაუკავშირდეს Istio Prometheus სერვისს 9090 პორტზე.

Flagger-ს აქვს Grafana-ს დაფა კანარის ანალიზისთვის. დააინსტალირეთ Grafana სახელების სივრცეში istio-system:

helm upgrade -i flagger-grafana flagger/grafana 
--namespace=istio-system 
--set url=http://prometheus.istio-system:9090 
--set user=admin 
--set password=change-me

გაამჟღავნეთ Grafana ღია კარიბჭის მეშვეობით ვირტუალური სერვისის შექმნით (შეცვალეთ example.com თქვენს დომენზე):

apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: grafana
  namespace: istio-system
spec:
  hosts:
    - "grafana.istio.example.com"
  gateways:
    - public-gateway.istio-system.svc.cluster.local
  http:
    - route:
        - destination:
            host: flagger-grafana

შეინახეთ ზემოაღნიშნული რესურსი, როგორც grafana-virtual-service.yaml და შემდეგ გამოიყენეთ იგი:

kubectl apply -f ./grafana-virtual-service.yaml

გადასვლისას http://grafana.istio.example.com ბრაუზერში თქვენ უნდა გადახვიდეთ Grafana-ს შესვლის გვერდზე.

ვებ აპლიკაციების დანერგვა Flagger-ით

Flagger ავრცელებს Kubernetes-ს და სურვილისამებრ მცირდება ავტომატურად (HPA), შემდეგ ქმნის ობიექტების სერიას (Kubernetes-ის განლაგება, ClusterIP სერვისები და Istio ვირტუალური სერვისები). ეს ობიექტები ამჟღავნებს აპლიკაციას სერვისის ქსელში და აკონტროლებს კანარის ანალიზს და პროგრესს.

შექმენით სატესტო სახელთა სივრცე, როდესაც ჩართულია Istio Sidecar ინექცია:

REPO=https://raw.githubusercontent.com/stefanprodan/flagger/master
kubectl apply -f ${REPO}/artifacts/namespaces/test.yaml

შექმენით განლაგება და pod ავტომატური მასშტაბის ინსტრუმენტი:

kubectl apply -f ${REPO}/artifacts/canaries/deployment.yaml
kubectl apply -f ${REPO}/artifacts/canaries/hpa.yaml

განათავსეთ ტესტის დატვირთვის სერვისი კანარის ანალიზის დროს ტრაფიკის შესაქმნელად:

helm upgrade -i flagger-loadtester flagger/loadtester 
--namepace=test

შექმენით მორგებული კანარის რესურსი (შეცვალეთ example.com თქვენს დომენზე):

apiVersion: flagger.app/v1alpha3
kind: Canary
metadata:
  name: podinfo
  namespace: test
spec:
  targetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: podinfo
  progressDeadlineSeconds: 60
  autoscalerRef:
    apiVersion: autoscaling/v2beta1
    kind: HorizontalPodAutoscaler
    name: podinfo
  service:
    port: 9898
    gateways:
    - public-gateway.istio-system.svc.cluster.local
    hosts:
    - app.istio.example.com
  canaryAnalysis:
    interval: 30s
    threshold: 10
    maxWeight: 50
    stepWeight: 5
    metrics:
    - name: istio_requests_total
      threshold: 99
      interval: 30s
    - name: istio_request_duration_seconds_bucket
      threshold: 500
      interval: 30s
    webhooks:
      - name: load-test
        url: http://flagger-loadtester.test/
        timeout: 5s
        metadata:
          cmd: "hey -z 1m -q 10 -c 2 http://podinfo.test:9898/"

შეინახეთ ზემოაღნიშნული რესურსი, როგორც podinfo-canary.yaml და შემდეგ გამოიყენეთ იგი:

kubectl apply -f ./podinfo-canary.yaml

ზემოაღნიშნული ანალიზი, წარმატების შემთხვევაში, გაგრძელდება ხუთი წუთის განმავლობაში, ყოველ ნახევარ წუთში HTTP მეტრიკის შემოწმებას. თქვენ შეგიძლიათ განსაზღვროთ მინიმალური დრო, რომელიც საჭიროა კანარის განლაგების დასადასტურებლად და ხელშეწყობისთვის შემდეგი ფორმულის გამოყენებით: interval * (maxWeight / stepWeight). კანარის CRD ველები დოკუმენტირებულია აქ.

რამდენიმე წამის შემდეგ, Flagger შექმნის კანარის ობიექტებს:

# applied 
deployment.apps/podinfo
horizontalpodautoscaler.autoscaling/podinfo
canary.flagger.app/podinfo
# generated 
deployment.apps/podinfo-primary
horizontalpodautoscaler.autoscaling/podinfo-primary
service/podinfo
service/podinfo-canary
service/podinfo-primary
virtualservice.networking.istio.io/podinfo

გახსენით ბრაუზერი და გადადით app.istio.example.com, თქვენ უნდა ნახოთ ვერსიის ნომერი დემო აპლიკაციები.

კანარის ავტომატური ანალიზი და პოპულარიზაცია

Flagger ახორციელებს საკონტროლო მარყუჟს, რომელიც თანდათანობით გადააქვს ტრაფიკს კანარისკენ, ხოლო გაზომავს ძირითადი შესრულების მეტრიკას, როგორიცაა HTTP მოთხოვნის წარმატების მაჩვენებელი, მოთხოვნის საშუალო ხანგრძლივობა და პოდის ჯანმრთელობა. KPI ანალიზის საფუძველზე, კანარის დაწინაურება ან შეწყვეტა ხდება და ანალიზის შედეგები ქვეყნდება Slack-ში.

კანარის განლაგება იწყება, როდესაც იცვლება ერთ-ერთი შემდეგი ობიექტი:

• განათავსეთ PodSpec (კონტეინერის სურათი, ბრძანება, პორტები, env და ა.შ.)
• ConfigMaps დამონტაჟებულია როგორც ტომი ან შედგენილია გარემოს ცვლადებზე
• საიდუმლოებები დამონტაჟებულია ტომებად ან გარდაიქმნება გარემოს ცვლადებად

გაუშვით canary deploy კონტეინერის სურათის განახლებისას:

kubectl -n test set image deployment/podinfo 
podinfod=quay.io/stefanprodan/podinfo:1.4.1

Flagger აღმოაჩენს, რომ განლაგების ვერსია შეიცვალა და იწყებს მის ანალიზს:

kubectl -n test describe canary/podinfo

Events:

New revision detected podinfo.test
Scaling up podinfo.test
Waiting for podinfo.test rollout to finish: 0 of 1 updated replicas are available
Advance podinfo.test canary weight 5
Advance podinfo.test canary weight 10
Advance podinfo.test canary weight 15
Advance podinfo.test canary weight 20
Advance podinfo.test canary weight 25
Advance podinfo.test canary weight 30
Advance podinfo.test canary weight 35
Advance podinfo.test canary weight 40
Advance podinfo.test canary weight 45
Advance podinfo.test canary weight 50
Copying podinfo.test template spec to podinfo-primary.test
Waiting for podinfo-primary.test rollout to finish: 1 of 2 updated replicas are available
Promotion completed! Scaling down podinfo.test

ანალიზის დროს, კანარის შედეგების თვალყურის დევნება შესაძლებელია Grafana-ს გამოყენებით:

გთხოვთ, გაითვალისწინოთ, რომ თუ კანარის ანალიზის დროს განთავსებაზე ახალი ცვლილებები იქნება გამოყენებული, მაშინ Flagger განაახლებს ანალიზის ფაზას.

შეადგინეთ ყველა კანარის სია თქვენს კლასტერში:

watch kubectl get canaries --all-namespaces
NAMESPACE   NAME      STATUS        WEIGHT   LASTTRANSITIONTIME
test        podinfo   Progressing   15       2019-01-16T14:05:07Z
prod        frontend  Succeeded     0        2019-01-15T16:15:07Z
prod        backend   Failed        0        2019-01-14T17:05:07Z

თუ ჩართული გაქვთ Slack შეტყობინებები, მიიღებთ შემდეგ შეტყობინებებს:

ავტომატური დაბრუნება

კანარის ანალიზის დროს, შეგიძლიათ შექმნათ სინთეზური HTTP 500 შეცდომები და მაღალი რეაგირების შეყოვნება, რათა ნახოთ, შეაჩერებს თუ არა Flagger დანერგვას.

შექმენით სატესტო განყოფილება და გააკეთეთ მასში შემდეგი:

kubectl -n test run tester 
--image=quay.io/stefanprodan/podinfo:1.2.1 
-- ./podinfo --port=9898
kubectl -n test exec -it tester-xx-xx sh

HTTP 500 შეცდომების გენერირება:

watch curl http://podinfo-canary:9898/status/500

დაგვიანების გენერაცია:

watch curl http://podinfo-canary:9898/delay/1

როდესაც წარუმატებელი შემოწმებების რაოდენობა მიაღწევს ზღურბლს, ტრაფიკი ბრუნდება თავდაპირველ არხზე, კანარის მასშტაბირება ხდება ნულამდე და განლაგება აღინიშნება წარუმატებლად.

კანარის შეცდომები და შეყოვნების მწვერვალები აღირიცხება Kubernetes-ის მოვლენებად და აღირიცხება Flagger-ის მიერ JSON ფორმატში:

kubectl -n istio-system logs deployment/flagger -f | jq .msg

Starting canary deployment for podinfo.test
Advance podinfo.test canary weight 5
Advance podinfo.test canary weight 10
Advance podinfo.test canary weight 15
Halt podinfo.test advancement success rate 69.17% < 99%
Halt podinfo.test advancement success rate 61.39% < 99%
Halt podinfo.test advancement success rate 55.06% < 99%
Halt podinfo.test advancement success rate 47.00% < 99%
Halt podinfo.test advancement success rate 37.00% < 99%
Halt podinfo.test advancement request duration 1.515s > 500ms
Halt podinfo.test advancement request duration 1.600s > 500ms
Halt podinfo.test advancement request duration 1.915s > 500ms
Halt podinfo.test advancement request duration 2.050s > 500ms
Halt podinfo.test advancement request duration 2.515s > 500ms
Rolling back podinfo.test failed checks threshold reached 10
Canary failed! Scaling down podinfo.test

თუ ჩართეთ Slack შეტყობინებები, მიიღებთ შეტყობინებას, როდესაც ვადა გადააჭარბებს ან ანალიზში წარუმატებელი შემოწმებების მაქსიმალურ რაოდენობას მიაღწევს:

დასასრულს

სერვისის ქსელის გაშვება, როგორიცაა Istio, Kubernetes-ის გარდა, უზრუნველყოფს ავტომატურ მეტრიკას, ჟურნალს და პროტოკოლებს, მაგრამ დატვირთვის განლაგება მაინც დამოკიდებულია გარე ინსტრუმენტებზე. Flagger მიზნად ისახავს შეცვალოს ეს Istio შესაძლებლობების დამატებით პროგრესული მიწოდება.

Flagger თავსებადია Kubernetes-ის ნებისმიერ CI/CD ხსნართან და კანარის ანალიზი ადვილად შეიძლება გაფართოვდეს ვებჰუკები სისტემური ინტეგრაციის/მიღების ტესტების, დატვირთვის ტესტების ან ნებისმიერი სხვა საბაჟო შემოწმების შესასრულებლად. ვინაიდან Flagger არის დეკლარაციული და პასუხობს Kubernetes მოვლენებს, მისი გამოყენება შესაძლებელია GitOps მილსადენებში ქსოვის ნაკადი ან ჯენკინსი X. თუ იყენებთ JenkinsX-ს, შეგიძლიათ დააინსტალიროთ Flagger jx დანამატებით.

Flagger-ის მხარდაჭერა ქსოვის ნაკეთობები და უზრუნველყოფს კანარის განლაგებას ქსოვის ღრუბელი. პროექტის ტესტირება მიმდინარეობს GKE-ზე, EKS-ზე და შიშველ მეტალზე kubeadm-ით.

თუ გაქვთ წინადადებები Flagger-ის გასაუმჯობესებლად, გთხოვთ, გამოაგზავნოთ პრობლემა ან PR GitHub-ზე სტეფანპროდანი/ფლაგერი. კონტრიბუცია მისასალმებელია!

მადლობა რეი ცანგი.

წყარო: www.habr.com