Citrix ADC Ingress Controller

Bereitstellung der Citrix ADC-integrierten Canary-Bereitstellungslösung

Canary Release ist eine Technik, um das Risiko der Einführung einer neuen Softwareversion in der Produktion zu verringern, indem die Änderung zunächst für eine kleine Untergruppe von Benutzern eingeführt wird. Nach der Benutzervalidierung wird die Anwendung für die größere Gruppe von Benutzern bereitgestellt.

Citrix bietet die folgenden Optionen für die Canary-Bereitstellung mit Citrix Ingress Controller.

In einer Bereitstellung, die das Canary-CRD verwendet, wird die Canary-Konfiguration mithilfe einer Kubernetes-CRD angewendet. Citrix unterstützt auch eine viel einfachere Option für die Canary-Bereitstellung mit Ingress-Anmerkungen.

Canary mit der Canary-CRD bereitstellen

Dieser Abschnitt enthält Informationen zur Canary-Bereitstellung mit der Canary-CRD.

Citrix ADC-integrierte Canary-Bereitstellungslösung fasst alle Komponenten der Continuous Delivery (CD) zusammen und erleichtert den Anwendungsentwicklern die Canary-Bereitstellung. Diese Lösung verwendet Spinnaker als kontinuierliche Lieferplattform und Kayenta als Spinnaker-Plug-In für die Canary-Analyse. Kayenta ist ein Open-Source-Analysedienst für Canaries, der benutzerdefinierte Metriken aus ihren Quellen abruft, statistische Tests durchführt und eine Gesamtpunktzahl für den Canary bereitstellt. Die Punktzahl aus statistischen Tests und Zählern sowie die Erfolgskriterien werden verwendet, um den Canary zu fördern oder zu versagen.

Citrix ADC wird mit einem umfangreichen anwendungszentrierten Konfigurationsmodul geliefert und bietet vollständige Transparenz des Anwendungsdatenverkehrs und des Zustands von Anwendungsinstanzen. Die Funktionen von Citrix ADC zur Erstellung genauer Leistungsstatistiken können für Canary-Analysen genutzt werden, um bessere Entscheidungen über die Canary-Bereitstellung zu treffen. In dieser Lösung ist Citrix ADC in die Spinnaker-Plattform integriert und dient als Quelle für die Bereitstellung präziser Metriken für die Analyse der Canary-Bereitstellung mit Kayenta.

Citrix ADC Metrics Exporter exportiert die Leistungsmetriken der Anwendung in das Open-Source-Überwachungssystem Prometheus und Sie können Kayenta so konfigurieren, dass die Metriken für die Canary-Bereitstellung abgerufen werden. Die Verkehrsverteilung auf die Canary-Version kann mit der Citrix ADC-Richtlinieninfrastruktur reguliert werden. Wenn Sie eine bestimmte Art von Datenverkehr von der Produktion zur Baseline und zum Canary umleiten möchten, können Sie Übereinstimmungsausdrücke verwenden, um den Datenverkehr mithilfe der umfangreichen Citrix ADC-Richtlinieninfrastruktur zur Baseline und zum Canary umzuleiten

Sie können beispielsweise den Datenverkehr mithilfe des Übereinstimmungsausdrucks HTTP.REQ.URL.CONTAINS (“Citrix India”) von der Produktion auf Canary und Baseline umleiten. Der Verkehr, der dem Ausdruck entspricht, wird auf Canary und Baseline umgeleitet und der verbleibende Verkehr geht in Produktion.

Die Komponenten, die Teil der Citrix Integrated Canary Deployment Solution sind, und ihre Funktionen werden wie folgt erklärt:

  • GitHub: GitHub bietet alle von Git bereitgestellten Funktionen zur verteilten Versionskontrolle und Quellcodeverwaltung und verfügt über zusätzliche Funktionen. GitHub verfügt über viele Dienstprogramme für die Integration mit anderen Tools, die Teil Ihrer CI/CD-Pipeline sind, wie Docker Hub und Spinnaker.

  • Docker Hub: Docker Hub ist ein Cloud-basierter Repository-Service von Docker zum Teilen und Auffinden von Docker-Images. Sie können GitHub mit Docker Hub integrieren, um automatisch Images aus dem Quellcode in GitHub zu erstellen und das erstellte Image an Docker Hub zu übertragen.

  • Spinnaker: Spinnaker ist eine Open Source, Multi-Cloud-Plattform für kontinuierliche Bereitstellung, mit der Softwareänderungen mit hoher Geschwindigkeit und Zuverlässigkeit veröffentlicht werden können. Sie können die Anwendungsbereitstellungsfunktionen von Spinnaker verwenden, um Workflows für die kontinuierliche Bereitstellung zu erstellen und zu verwalten. Das wichtigste Deployment Management-Konstrukt in Spinnaker ist als Pipeline bekannt. Pipelines in Spinnaker bestehen aus einer Abfolge von Aktionen, die als Stufen bezeichnet werden. Spinnaker bietet verschiedene Phasen für die Bereitstellung einer Anwendung, das Ausführen eines Skripts, die Durchführung von Canary-Analysen, das Entfernen der Bereitstellung usw. Sie können Spinnaker in viele Tools von Drittanbietern integrieren, um viele zusätzliche Funktionen zu unterstützen.

  • Prometheus: Prometheus ist ein Open-Source-Toolkit zur Überwachung und Alarmierung von Systemen. Prometheus ist ein Überwachungssystem, das eine große Datenmenge in einer Zeitreihendatenbank verwalten kann. Citrix ADC Metrics macht Spinnaker die Leistungsmetriken über Prometheus zugänglich.

  • Jenkins: Jenkins ist ein Open Source-Automatisierungsserver, mit dem alle Arten von Aufgaben im Zusammenhang mit dem Erstellen, Testen und Bereitstellen oder Bereitstellen von Software automatisiert werden können. Jenkins unterstützt auch die Ausführung benutzerdefinierter Skripte als Teil Ihres Bereitstellungszyklus.

  • Citrix Ingress Controller Citrix bietet einen Ingress Controller für Citrix ADC MPX (Hardware), Citrix ADC VPX (virtualisiert) und Citrix ADC CPX (containerisiert) für Bare-Metal- und Cloud-Bereitstellungen. Der Citrix Ingress Controller basiert auf Kubernetes Ingress und konfiguriert automatisch einen oder mehrere Citrix ADCs basierend auf der Ingress-Ressourcenkonfiguration.

Die folgenden Citrix Softwareversionen sind für die Citrix Integrated Canary Deployment Solution erforderlich:

  • Build/Version Citrix Ingress Controller: quay.io/citrix/citrix-k8s-ingress-controller:1.26.7.
  • Citrix ADC CPX-Version: quay.io/citrix/citrix-k8s-cpx-ingress:13.0-83.27.
  • Citrix ADC Metrics Exporter Version: quay.io/citrix/netscaler-metrics-exporter:1.4.0.

Workflow einer Spinnaker-Pipeline für Citrix ADC-integrierte Canary-Bereitstellungslösung

Das folgende Diagramm erklärt den Workflow einer Spinnaker-Pipeline für die in Citrix ADC integrierte Canary Deployment Solution.

Spinnaker_pipeline

In den folgenden Schritten wird der im Diagramm angegebene Arbeitsablauf erläutert.

  1. Entwickler verwalten den Quellcode in GitHub, nehmen bei Bedarf Änderungen vor und übertragen die Änderungen an GitHub.
  2. In GitHub ist ein Webhook konfiguriert, um auf Änderungen des Quellcodes zu achten. Immer wenn der Quellcode in GitHub eingecheckt wird, wird der Webhook ausgelöst und informiert Docker Hub, das Image mit dem neuen Quellcode zu erstellen. Sobald das Docker-Image erstellt wurde, löst ein separater Webhook, der in Docker Hub konfiguriert ist, eine Spinnaker-Pipeline aus.
  3. Sobald die Spinnaker-Pipeline ausgelöst wurde, werden Canary- und Baseline-Versionen des Images bereitgestellt.
  4. Sobald die Canary- und Baseline-Versionen bereitgestellt sind, wird ein gewisser Prozentsatz des Datenverkehrs von der Produktion auf die Canary- und Basisversion umgeleitet Citrix ADC sammelt die Leistungsstatistiken und exportiert die Statistiken mithilfe von Citrix ADC Metrics Exporter nach Prometheus. Prometheus gibt diese Statistiken zur Canary-Analyse an Kayenta weiter.

  5. Kayenta führt eine Canary-Analyse basierend auf den Leistungsstatistiken durch und generiert eine Punktzahl. Basierend auf der Punktzahl wird die Canary-Bereitstellung als Erfolg oder Misserfolg bezeichnet und das Image wird ausgerollt oder zurückgesetzt.

Bereitstellen der Citrix ADC-integrierten Canary-Bereitstellungslösung auf der Google Cloud Platform

Dieser Abschnitt enthält Informationen zum Einrichten von Spinnaker, zum Erstellen einer Spinnaker-Pipeline und ein Beispiel für eine Canary-Bereitstellung.

Spinnaker auf der Google Cloud Platform bereitstellen

Dieses Thema enthält Informationen zur Bereitstellung von Spinnaker und zur Integration von Plug-Ins mit Spinnaker für die Canary-Bereitstellung auf der Google Cloud Platform (GCP).

Führen Sie die folgenden Schritte aus, um Spinnaker bereitzustellen und Plug-Ins in GCP zu integrieren.

  1. Richten Sie die Umgebung ein und erstellen Sie mit den folgenden Befehlen einen GKE-Cluster.

    export GOOGLE_CLOUD_PROJECT=[PROJECT_ID] 
    gcloud config set project $GOOGLE_CLOUD_PROJECT 
    gcloud config set compute/zone us-central1-f
    gcloud services enable container.googleapis.com
    gcloud beta container clusters create kayenta-tutorial 
    --machine-type=n1-standard-2 --enable-stackdriver-kubernetes
    
  2. Installieren Sie das Plug-in für die Integration von Prometheus mit Stackdriver mit dem folgenden Befehl.

    kubectl apply --as=admin --as-group=system:masters -f \
    https://storage.googleapis.com/stackdriver-prometheus-documentation/rbac-setup.yml
    curl -sS "https://storage.googleapis.com/stackdriver-prometheus-documentation/prometheus-service.yml" | 
    \sed "s/_stackdriver_project_id:.*/_stackdriver_project_id: $GOOGLE_CLOUD_PROJECT/" | 
    \sed "s/_kubernetes_cluster_name:.*/_kubernetes_cluster_name: kayenta-tutorial/" | 
    \sed "s/_kubernetes_location:.*/_kubernetes_location: us-central1-f/" | 
    \kubectl apply -f -
    
  3. Stellen Sie Spinnaker mithilfe der folgenden Schritte im GKE-Cluster bereit.

    1. Laden Sie die Datei quick-install.yml für Spinnaker von der Spinnaker-Website herunter.
    2. Aktualisieren Sie die Datei quick-install.yml, um verschiedene Komponenten zu integrieren, beginnend mit Docker Hub. Um Spinnaker in Docker Hub zu integrieren, aktualisieren Sie die Werte von Adresse, Benutzername, Kennwort, E-Mail und Repository unter ConfigMap in der Datei quick-install.yml.

      dockerRegistry:
                  enabled: true
                  accounts:
                  - name: my-docker-registry
                  requiredGroupMembership: []
                  providerVersion: V1
                  permissions: {}
                  address: https://index.docker.io
                  username: <username>
                  password: <password>
                  email: <mail-id>
                  cacheIntervalSeconds: 30
                  clientTimeoutMillis: 60000
                  cacheThreads: 1
                  paginateSize: 100
                  sortTagsByDate: false
                  trackDigests: false
                  insecureRegistry: false
                  repositories:- <repository-name>
                  primaryAccount: my-docker-registry
      
    3. (Optional) Führen Sie die folgenden Schritte aus, um Jenkins einzurichten.

      sudo apt-get update
      sudo apt-get upgrade
      sudo apt-get install openjdk-8-jdk
      wget -q -O - https://jenkins-ci.org/debian/jenkins-ci.org.key |       
      sudo apt-key add -
      sudo sh -c 'echo deb http://pkg.jenkins-ci.org/debian binary/ > /etc/apt/sources.list.d/jenkins.list'
      sudo apt-get update
      sudo apt-get install jenkins git
      sudo apt-get install software-properties-common python-software-properties apt-transport-https
      sudo add-apt-repository https://dl.bintray.com/spinnaker-releases/debians
      

      Hinweis:

      Wenn Jenkins in einem der Knoten von Kubernetes installiert ist, müssen Sie die Firewallregeln für diesen Knoten für den öffentlichen Zugriff aktualisieren.

    4. Aktualisieren Sie die folgenden Werte in der Datei quick-install.yml, um Jenkins mit Spinnaker zu integrieren.

          data:igor.yml: |
      enabled: true
      skipLifeCycleManagement: false
          ci:jenkins:
      enabled: true
        masters: 
      - name: master
            address: <endpoint>
          username: <username>
        password: <password>
      
    5. Informationen zum Einrichten von Prometheus und Grafanafinden Sie im Abschnitt Prometheus and Grafana-Integration im Citrix ADC Metrics Exporter und führen Sie die Schritte aus.

    6. Um Prometheus in Spinnaker zu integrieren, aktualisieren Sie die folgenden Werte in der Datei quick-install.yml.

        data:
        config: | 
          deploymentConfigurations:
          canary:
          enabled: true
      serviceIntegrations:
            - name: prometheus
        enabled: true
      accounts:
        - name: my-prometheus
      endpoint:
            baseUrl: prometheus-endpoint
          supportedTypes:
      - METRICS_STORE
        data:
        config: |
          deploymentConfigurations:
          metricStores:
            prometheus:
            enabled: true
            add_source_metalabels: true
            stackdriver:
        enabled: true
          period: 30
          enabled: true
      
    7. Um Slack für Benachrichtigungen mit Spinnaker zu integrieren, aktualisieren Sie die folgenden Werte in der Datei quick-install.yml.

      data:
       config: |
        deploymentConfigurations:
         notifications:
          slack:
           enabled: true
            botName: <BotName>
            token: <token>
      
    8. Sobald alle erforderlichen Komponenten integriert sind, stellen Sie Spinnaker bereit, indem Sie den folgenden Schritt ausführen.

      kubectl apply -f quick-install.yaml
      
    9. Überprüfen Sie den Fortschritt der Bereitstellung mit dem folgenden Befehl. Sobald die Bereitstellung abgeschlossen ist, gibt dieser Befehl alle Pods als Ready x/x aus.

      watch kubectl -n spinnaker get pods
      
  4. Sobald Sie Spinnaker bereitgestellt haben, können Sie die Bereitstellung mit den folgenden Schritten testen:

    1. Ermöglichen Sie den Spinnaker-Zugriff, indem Sie mit dem folgenden Befehl einen lokalen Port an die Deckkomponente von Spinnaker weiterleiten:

      DECK_POD=$(kubectl -n spinnaker get pods -l \
      cluster=spin-deck,app=spin \
      -o=jsonpath='{.items[0].metadata.name}')
      kubectl -n spinnaker port-forward $DECK_POD 8080:9000 >/dev/null &
      
    2. Um auf Spinnaker zuzugreifen, klicken Sie in der Cloud Shell auf das Symbol für die Webvorschau und wählen Sie Vorschau auf Port 8080.

      Hinweis:

      Du kannst sicher oder über HTTP auf Spinnaker zugreifen. Um Spinnaker sicher verfügbar zu machen, verwenden Sie die Datei spin-ingress-ssl.yaml, um den Ingress bereitzustellen. Sobald die Spinnaker-Anwendung öffentlich zugänglich ist, können Sie die für Spinnaker zugewiesene Domain oder die IP-Adresse des Ingress verwenden, um darauf zuzugreifen.

Erstellen Sie eine Spinnaker-Pipeline und konfigurieren Sie die automatisierte Canary-Bereitstellung

Sobald Sie Spinnaker bereitgestellt haben, erstellen Sie eine Spinnaker-Pipeline für eine Anwendung und konfigurieren Sie die automatisierte Canary-Bereitstellung

  1. Erstellen Sie eine Anwendung in Spinnaker.
  2. Erstellen Sie eine Spinnaker-Pipeline. Sie können die Pipeline mithilfe der Beispieldatei in JSON-Beispieldateien als JSON-Dateibearbeiten.
  3. Erstellen Sie in Spinnaker eine automatisierte Canary-Konfiguration für die automatisierte Canary-Analyse. Sie können die in der JSON-Datei bereitgestellte Konfiguration als Beispiel für eine automatische Canary-Konfiguration verwenden. Beispiel-JSON-Dateien.

Bereitstellen einer Musteranwendung für Canary

Dieses Beispiel zeigt, wie die die Canary-Bereitstellung einer Beispielanwendung mit Citrix ADC-integrierter Canary Deployment Solution ausgeführt wird. In diesem Beispiel wird Citrix ADC CPX, MPX oder VPX als Ingress-Gerät für einen GKE-Cluster bereitgestellt. Citrix ADC generiert die für die Canary-Analyse erforderlichen Leistungsmetriken.

Als Voraussetzung müssen Sie den folgenden Schritt ausführen, bevor Sie die Beispielanwendung bereitstellen.

Bereitstellen der Beispielanwendung

Führen Sie die folgenden Schritte aus, um eine Beispielanwendung als Canary bereitzustellen.

  1. Erstellen Sie die erforderlichen RBAC-Regeln für Citrix ADC, indem Sie die Datei rbac.yaml bereitstellen.

    kubectl apply -f rbac.yaml 
    
  2. Sie können den Citrix Ingress Controller entweder als Beiwagen mit Citrix ADC CPX oder als eigenständigen Pod bereitstellen, der Citrix ADC VPX oder MPX steuert.

    Verwenden Sie die Datei cpx-with-cic-sidecar.yml, um den Citrix Ingress Controller als Beiwagen mit Citrix ADC CPX bereitzustellen. Es stellt auch Citrix ADC Metrics Exporter auf demselben Pod bereit.

    kubectl apply -f cpx-with-cic-sidecar.yml 
    

    Um den Citrix Ingress Controller als eigenständigen Pod für Citrix ADC VPX oder MPX bereitzustellen, verwenden Sie die Datei cic-vpx.yaml . In dieser Bereitstellung sollten Sie die exporter.yaml-Datei verwenden, um Citrix ADC Metrics Exporter bereitzustellen.

    kubectl apply -f cic-vpx.yaml
    kubectl apply -f exporter.yaml
    

    Hinweis:

    Je nachdem, wie Sie den Citrix Ingress Controller bereitstellen, müssen Sie die YAML-Datei für die Bereitstellung des Citrix Ingress Controller bearbeiten und die Werte für die Umgebungsvariablen ändern, wie in der Bereitstellung von Citrix Ingress Controllerangegeben.

  3. Stellen Sie den Ingress zur sicheren Bereitstellung von Spinnaker mithilfe der Datei spin-ingress-ssl.yaml bereit.

    kubectl apply -f spin-ingress-ssl.yaml 
    

    Hinweis:

    Weitere Informationen zum Erstellen eines TLS-Zertifikats für Ingress finden Sie unter TLS-Zertifikate in Citrix Ingress Controller.

  4. Sobald Spinnaker mit Citrix ADC verfügbar gemacht wurde, greifen Sie auf Spinnaker zu und führen Sie die Schritte unter Erstellen einer Spinnaker-Pipeline aus und konfigurieren Sie die automatische Canary-Bereitstellung, falls die Schritte noch nicht ausgeführt sind.

  5. Stellen Sie die Produktionsversion der Anwendung mithilfe der Datei production.yaml bereit.

    kubectl apply -f production.yaml 
    
  6. Erstellen Sie die Ingress-Ressourcenregel, um mithilfe der Datei ingress.yaml Datenverkehr von außerhalb des Clusters für Dienste innerhalb des Clusters verfügbar zu machen.

    kubectl apply -f ingress.yaml 
    
  7. Erstellen Sie mit der Datei service.yaml einen Kubernetes-Dienst für die Anwendung, die eine Canary-Bereitstellung benötigt.

    kubectl apply -f service.yaml
    
  8. Stellen Sie die Canary-CRD, die die Canary-Konfiguration definiert, mithilfe der canary-crd-class.yaml-Datei bereit.

    kubectl apply -f canary-crd-class.yaml
    

    Hinweis:

    Warten Sie nach dem Erstellen der CRD 10 Sekunden, bevor Sie das CRD-Objekt anwenden.

  9. Erstellen Sie ein CRD-Objekt canary-crd-object.yaml basierend auf der Canary-CRD zum Anpassen der Canary-Konfiguration.

    kubectl apply -f canary-crd-object.yaml
    

    In der folgenden Tabelle werden die Felder im Canary-CRD-Objekt erläutert.

    Feld Beschreibung
    serviceNames Liste der Dienste, auf die diese CRD angewendet werden muss
    deployment Gibt die Bereitstellungsstrategie als Kayenta an.
    percentage Gibt den Prozentsatz des Verkehrs an, der von Produktion zur Baseline und zum Canary umgeleitet
    matchExpression (optional) Jede von Citrix ADC unterstützte Richtlinie, mit der die Teilmenge der Benutzer definiert werden kann, die zu Canary- und Baseline-Versionen weitergeleitet werden sollen. Wenn x Prozent des Datenverkehrs konfiguriert sind, werden aus einer Teilmenge von Benutzern, die matchExpression entsprechen, nur x Prozent der Benutzer zur Baseline und zum Canary umgeleitet. Verbleibende Benutzer werden zu Produktion umgeleitet.
    Spinnaker Gibt die Spinnaker-Pipeline-Konfigurationen an, die Sie für Ihre Dienste anwenden möchten.
    Domäne IP-Adresse oder Domainname des Spinnaker-Gates.
    Port Portnummer des Spinnaker-Gates.
    applicationName Der Name der Anwendung in Spinnaker.
    pipelineName Der Name der Pipeline unter der Spinnaker-Anwendung.
    serviceName Gibt den Namen des Dienstes an, auf den Sie die Spinnaker-Konfiguration anwenden möchten.
  10. Stellen Sie Canary und Baseline-Versionen der Anwendung bereit.

    Hinweis:

    Wenn Sie die Canary Bereitstellung vollständig automatisieren, stellen Sie Canary- und Baseline-Versionen mithilfe des Deploy-Schritts (Manifest) in der Spinnaker-Pipeline bereit, und Sie müssen diesen Schritt nicht ausführen.

    Verwenden Sie für die manuelle Bereitstellung von Canary- und Baseline-Versionen canary.yaml - und baseline.yaml-Dateien .

    kubectl apply -f canary.yaml
    kubectl apply -f baseline.yaml
    

Problembehandlung

Führen Sie zur Problembehandlung bei der Bereitstellung die folgenden Schritte aus.

  1. Überprüfen Sie die Pod-Protokolle für die jeweiligen Komponenten wie Spinnaker, Prometheus, Kayenta, Citrix ADC CPX, Citrix ADC Metrics Exporter, Citrix Ingress Controller.
  2. Überprüfen Sie die Pod-Protokolle des Citrix Ingress Controller auf konfigurationsbezogene Fehler bei der Konfiguration des Citrix Proxys.
  3. Suchen Sie in den Citrix Ingress Controller-Podprotokollen nach dem Schlüsselwort exception/Exception, um die Probleme einzugrenzen.
  4. Suchen Sie nach den Protokollen vor der Suche. Suchen Sie nach der Konfiguration, die fehlgeschlagen ist und das Problem verursacht hat.
  5. Prüfen Sie die Fehlerursache während der Konfiguration.
  6. Wenn der Fehler aufgrund einer falschen Konfiguration aufgetreten ist, korrigieren Sie die Konfiguration.

JSON-Beispieldateien

Dieses Thema enthält JSON-Beispieldateien für die Konfiguration der Spinnaker-Pipeline und die automatisierte Canary-Konfiguration. Diese Dateien können als Referenz beim Erstellen der Spinnaker-Pipeline und der automatisierten Canary-Konfiguration verwendet werden.

Eine JSON-Beispieldatei für die Konfiguration der Spinnaker-Pipeline**

{
  "appConfig": {},
  "description": "This pipeline deploys a canary version of the application, and a baseline (identical to production) version.\nIt compares them, and if the canary is OK, it triggers the production deployment pipeline.",
  "executionEngine": "v2",
  "expectedArtifacts": [
    {
      "defaultArtifact": {
        "kind": "custom"
      },
      "id": "ac842617-988f-48dc-a7a4-7f020d93cc42",
      "matchArtifact": {
        "kind": "docker",
        "name": "index.docker.io/sample/demo",
        "type": "docker/image"
      },
      "useDefaultArtifact": false,
      "usePriorExecution": false
    }
  ],
  "keepWaitingPipelines": false,
  "lastModifiedBy": "anonymous",
  "limitConcurrent": true,
  "parallel": true,
  "parameterConfig": [],
  "stages": [
    {
      "account": "my-kubernetes-account",
      "cloudProvider": "kubernetes",
      "kinds": [
        "Deployment",
        "ConfigMap"
      ],
      "labelSelectors": {
        "selectors": [
          {
            "key": "version",
            "kind": "EQUALS",
            "values": [
              "canary"
            ]
          }
        ]
      },
      "location": "default",
      "name": "Delete Canary",
      "options": {
        "cascading": true
      },
      "refId": "12",
      "requisiteStageRefIds": [
        "19",
        "26"
      ],
      "type": "deleteManifest"
    },
    {
      "account": "my-kubernetes-account",
      "cloudProvider": "kubernetes",
      "kinds": [
        "Deployment"
      ],
      "labelSelectors": {
        "selectors": [
          {
            "key": "version",
            "kind": "EQUALS",
            "values": [
              "baseline"
            ]
          }
        ]
      },
      "location": "default",
      "name": "Delete Baseline",
      "options": {
        "cascading": true
      },
      "refId": "13",
      "requisiteStageRefIds": [
        "19",
        "26"
      ],
      "type": "deleteManifest"
    },
    {
      "name": "Successful deployment",
      "preconditions": [],
      "refId": "14",
      "requisiteStageRefIds": [
        "12",
        "13"
      ],
      "type": "checkPreconditions"
    },
    {
      "application": "sampleapplicaion",
      "expectedArtifacts": [
        {
          "defaultArtifact": {
            "kind": "custom"
          },
          "id": "9185c756-c6cd-49bc-beee-e3f7118f3412",
          "matchArtifact": {
            "kind": "docker",
            "name": "index.docker.io/sample/demo",
            "type": "docker/image"
          },
          "useDefaultArtifact": false,
          "usePriorExecution": false
        }
      ],
      "failPipeline": true,
      "name": "Deploy to Production",
      "pipeline": "7048e5ac-2464-4557-a05a-bec8bdf868fc",
      "refId": "19",
      "requisiteStageRefIds": [
        "25"
      ],
      "stageEnabled": {
        "expression": ""${ #stage('Canary Analysis')['status'].toString() == 'SUCCEEDED'}"",
        "type": "expression"
      },
      "type": "pipeline",
      "waitForCompletion": true
    },
    {
      "account": "my-kubernetes-account",
      "cloudProvider": "kubernetes",
      "manifestArtifactAccount": "embedded-artifact",
      "manifests": [
        {
          "apiVersion": "apps/v1",
          "kind": "Deployment",
          "metadata": {
            "labels": {
              "name": "sampleapplicaion-prod",
              "version": "baseline"
            },
            "name": "sampleapplicaion-baseline-deployment",
            "namespace": "default"
          },
          "spec": {
            "replicas": 4,
            "strategy": {
              "rollingUpdate": {
                "maxSurge": 10,
                "maxUnavailable": 10
              },
              "type": "RollingUpdate"
            },
            "template": {
              "metadata": {
                "labels": {
                  "name": "sampleapplicaion-prod"
                }
              },
              "spec": {
                "containers": [
                  {
                    "image": "index.docker.io/sample/demo:v1",
                    "imagePullPolicy": "Always",
                    "name": "sampleapplicaion-prod",
                    "ports": [
                      {
                        "containerPort": 8080,
                        "name": "port-8080"
                      }
                    ]
                  }
                ]
              }
            }
          }
        }
      ],
      "moniker": {
        "app": "sampleapplicaion"
      },
      "name": "Deploy Baseline",
      "refId": "20",
      "relationships": {
        "loadBalancers": [],
        "securityGroups": []
      },
      "requisiteStageRefIds": [],
      "source": "text",
      "type": "deployManifest"
    },
    {
      "account": "my-kubernetes-account",
      "cloudProvider": "kubernetes",
      "manifestArtifactAccount": "embedded-artifact",
      "manifests": [
        {
          "apiVersion": "apps/v1",
          "kind": "Deployment",
          "metadata": {
            "labels": {
              "name": "sampleapplicaion-prod",
              "version": "canary"
            },
            "name": "sampleapplicaion-canary-deployment",
            "namespace": "default"
          },
          "spec": {
            "replicas": 4,
            "strategy": {
              "rollingUpdate": {
                "maxSurge": 10,
                "maxUnavailable": 10
              },
              "type": "RollingUpdate"
            },
            "template": {
              "metadata": {
                "labels": {
                  "name": "sampleapplicaion-prod"
                }
              },
              "spec": {
                "containers": [
                  {
                    "image": "index.docker.io/sample/demo",
                    "imagePullPolicy": "Always",
                    "name": "sampleapplicaion-prod",
                    "ports": [
                      {
                        "containerPort": 8080,
                        "name": "port-8080"
                      }
                    ]
                  }
                ]
              }
            }
          }
        }
      ],
      "moniker": {
        "app": "sampleapplicaion"
      },
      "name": "Deploy Canary",
      "refId": "21",
      "relationships": {
        "loadBalancers": [],
        "securityGroups": []
      },
      "requiredArtifactIds": [
        "ac842617-988f-48dc-a7a4-7f020d93cc42"
      ],
      "requisiteStageRefIds": [],
      "source": "text",
      "type": "deployManifest"
    },
    {
      "analysisType": "realTime",
      "canaryConfig": {
        "beginCanaryAnalysisAfterMins": "2",
        "canaryAnalysisIntervalMins": "",
        "canaryConfigId": "7bdb4ab4-f933-4a41-865f-6d3e9c786351",
        "combinedCanaryResultStrategy": "LOWEST",
        "lifetimeDuration": "PT0H5M",
        "metricsAccountName": "my-prometheus",
        "scopes": [
          {
            "controlLocation": "default",
            "controlScope": "k8s-sampleapplicaion.default.80.k8s-sampleapplicaion.default.8080.svc-baseline",
            "experimentLocation": "default",
            "experimentScope": "k8s-sampleapplicaion.default.80.k8s-sampleapplicaion.default.8080.svc-canary",
            "extendedScopeParams": {},
            "scopeName": "default"
          }
        ],
        "scoreThresholds": {
          "marginal": "0",
          "pass": "70"
        },
        "storageAccountName": "kayenta-minio"
      },
      "name": "Canary Analysis",
      "refId": "25",
      "requisiteStageRefIds": [
        "20",
        "21"
      ],
      "type": "kayentaCanary"
    },
    {
      "continuePipeline": false,
      "failPipeline": true,
      "job": "NJob",
      "master": "master",
      "name": "Auto Cleanup:  GCR Image and code revert",
      "parameters": {},
      "refId": "26",
      "requisiteStageRefIds": [
        "25"
      ],
      "stageEnabled": {
        "type": "expression"
      },
      "type": "jenkins"
    }
  ],
  "triggers": [
    {
      "account": "my-docker-registry",
      "enabled": true,
      "expectedArtifactIds": [
        "ac842617-988f-48dc-a7a4-7f020d93cc42"
      ],
      "organization": "sample",
      "payloadConstraints": {},
      "registry": "index.docker.io",
      "repository": "sample/demo",
      "source": "dockerhub",
      "type": "webhook"
    }
  ],
  "updateTs": "1553144362000"
}
<!--NeedCopy-->

Eine JSON-Beispieldatei für die automatisierte Canary-Konfiguration

Es folgt eine Beispiel-JSON-Datei für die automatische Canary-Konfiguration.

{
  "applications": [
    "sampleapplicaion"
  ],
  "classifier": {
    "groupWeights": {
      "Group 1": 70,
      "Group 2": 30
    },
    "scoreThresholds": {
      "marginal": 75,
      "pass": 95
    }
  },
  "configVersion": "1",
  "createdTimestamp": 1552650414234,
  "createdTimestampIso": "2019-03-15T11:46:54.234Z",
  "description": "Canary Config",
  "judge": {
    "judgeConfigurations": {},
    "name": "NetflixACAJudge-v1.0"
  },
  "metrics": [
    {
      "analysisConfigurations": {
        "canary": {
          "direction": "increase"
        }
      },
      "groups": [
        "Group 1"
      ],
      "name": "Server Response Errors - 5XX",
      "query": {
        "customFilterTemplate": "tot_requests",
        "metricName": "netscaler_lb_vserver_svr_busy_err_rate",
        "serviceType": "prometheus",
        "type": "prometheus"
      },
      "scopeName": "default"
    },
    {
      "analysisConfigurations": {
        "canary": {
          "direction": "either",
          "nanStrategy": "replace"
        }
      },
      "groups": [
        "Group 2"
      ],
      "name": "Server Response Latency - TTFB",
      "query": {
        "customFilterTemplate": "ttfb",
        "metricName": "netscaler_lb_vserver_hits_total",
        "serviceType": "prometheus",
        "type": "prometheus"
      },
      "scopeName": "default"
    }
  ],
  "name": "canary-config",
  "templates": {
    "tot_requests": "lb_vserver_name = "${scope}"",
    "ttfb": "lb_vserver_name = "${scope}""
  },
  "updatedTimestamp": 1553098513495,
  "updatedTimestampIso": "2019-03-20T16:15:13.495Z"
}
<!--NeedCopy-->

Vereinfachte Canary-Bereitstellung mit Ingress-Anmerkungen

Dieses Thema enthält Informationen zur vereinfachten Bereitstellung von Canary mithilfe von Ingress-Anmerkungen. Citrix bietet zwar mehrere Optionen zur Unterstützung der Canary Bereitstellung, dies ist jedoch eine einfachere Art der Canary-Bereitstellung.

Canary mit Ingress-Anmerkungen ist ein regelbasierter Canary-Bereitstellung Bei diesem Ansatz müssen Sie ein zusätzliches Ingress-Objekt mit spezifischen Anmerkungen definieren, um anzugeben, dass die Anwendungsanfrage basierend auf der regelbasierten Canary-Bereitstellungsstrategie bedient werden muss. In der Citrix Lösung kann Canary-basiertes Traffic-Routing auf Ingress-Ebene erreicht werden, indem verschiedene Regelsätze wie folgt definiert werden:

  • Anwendung der Canary Regeln basierend auf dem Gewicht
  • Anwendung der Canary-Regeln basierend auf dem HTTP-Request-Header
  • Anwenden der Canary-Regeln basierend auf dem HTTP-Header-Wert

Die Rangfolge der Canary Regeln ist wie folgt:

Canary nach HTTP-Request-Header-Wert -> Canary von HTTP-Request-

Canary-Bereitstellung basierend auf Gewichtung

Der gewichtungsbasierte Canary-Bereitstellung ist ein weit verbreiteter Ansatz zur Canary-Bereitstellung Bei diesem Ansatz können Sie eine Gewichtung in einem Bereich von 0 bis 100 festlegen, der den Prozentsatz des Datenverkehrs bestimmt, der zur Canary-Version und zur Produktionsversion einer Anwendung geleitet werden soll.

Im Folgenden finden Sie den Workflow für die gewichtungsbasierte Canary-Bereitstellung:

  • Zu Beginn kann die Gewichtung auf Null gesetzt werden, was darauf hinweist, dass der Verkehr nicht an die Canary-Version weitergeleitet wird.

  • Sobald Sie sich für die Canary-Bereitstellung entschieden haben, ändern Sie das Gewicht auf den erforderlichen Prozentsatz, um sicherzustellen, dass der Verkehr auch auf die Canary-Version gerichtet ist.

  • Wenn Sie schließlich feststellen, dass die Canary-Version zur Veröffentlichung bereit ist, ändern Sie das Gewicht auf 100, um sicherzustellen, dass der gesamte Verkehr auf die Canary-Version geleitet wird.

Um gewichtungsbasierte Canaries mit dem Citrix Ingress Controller bereitzustellen, erstellen Sie einen neuen Ingress mit einer Canary Anmerkung ingress.citrix.com/canary-weight: und geben Sie den Prozentsatz des Datenverkehrs an, der zur Canary-Version geleitet werden soll.

Canary-Bereitstellung basierend auf dem Header der HTTP-Anforderung

Sie können die Canary-Bereitstellung basierend auf dem HTTP-Request-Header konfigurieren, der von Clients gesteuert wird. Der Request-Header benachrichtigt den Ingress, die Anforderung an den im Canary Ingress angegebenen Dienst weiterzuleiten. Wenn der Request-Header den in der Ingress-Annotation genannten Wert enthält ingress.citrix.com/canary-by-header:, wird die Anforderung an den im Canary Ingress angegebenen Dienst weitergeleitet.

Canary-Bereitstellung basierend auf dem Header-Wert der HTTP-

Sie können die Canary-Bereitstellung auch basierend auf Werten des HTTP-Anforderungshaders konfigurieren, der eine Erweiterung von Canary nach Header ist. In dieser Bereitstellung geben Sie zusammen mit der Anmerkung ingress.citrix.com/canary-by-header: auch die Anmerkung ingress.citrix.com/canary-by-header-value: an. Wenn der Request-Header-Wert mit dem in der Ingress-Annotation ingress.citrix.com/canary-by-header-value:angegebenen Wert übereinstimmt, wird die Anforderung an den im Canary Ingress angegebenen Dienst weitergeleitet. Sie können mehrere Header-Werte als Liste von Zeichenfolgen angeben.

Es folgt eine Beispielanmerkung für die Canary-Bereitstellung basierend auf den Header-Werten der HTTP-Anforderung:

ingress.citrix.com/canary-by-header-value: ‘[“value1”,”value2”,”value3”,”value4”]’

Konfigurieren der Canary-Bereitstellung mit Ingress-Anmerkungen

Führen Sie die folgenden Schritte aus, um eine Beispielanwendung als Canary bereitzustellen.

  1. Stellen Sie den Citrix Ingress Controller mithilfe der Schritte unter Bereitstellen des Citrix Ingress Controllerbereit. Sie können den Citrix Ingress Controller entweder als Beiwagen mit Citrix ADC CPX oder als eigenständigen Pod bereitstellen, der Citrix ADC VPX oder MPX steuert.

  2. Stellen Sie die Anwendung Guestbook mit der Datei Guestbook-deploy.yaml bereit.

    kubectl apply -f guestbook-deploy.yaml
    
  3. Stellen Sie mit der Datei Guestbook-service.yaml einen Dienst bereit, um die Anwendung Guestbook verfügbar zu machen.

    kubectl apply -f guestbook-service.yaml
    
  4. Stellen Sie das Ingress-Objekt für die Anwendung Guestbook mit der Datei Guestbook-ingress.yaml bereit.

      kubectl apply -f  guestbook-ingress.yaml
    
  5. Stellen Sie eine Canary-Version der Anwendung Guestbook mit der Datei canary-deployment.yaml bereit.

        kubectl apply –f canary-deployment.yaml
    
  6. Stellen Sie mit der Datei canary-service.yaml einen Dienst bereit, um die Canary-Version der Anwendung Guestbook verfügbar zu machen.

        kubectl apply –f canary-service.yaml       
    
  7. Stellen Sie mit der Datei canary-ingress.yaml ein Ingress-Objekt mit Anmerkungen für die Canary-Version der Anwendung Guestbook bereit.

        kubectl apply –f canary-ingress.yaml
    
    
    
          apiVersion: networking.k8s.io/v1
          kind: Ingress
          metadata:
            annotations:
              ingress.citrix.com/canary-weight: "10"
              kubernetes.io/ingress.class: citrix
            name: canary-by-weight
          spec:
            rules:
            - host: webapp.com
              http:
                paths:
                - backend:
                    service:
                      name: guestbook-canary
                      port:
                        number: 80
                  path: /
                  pathType: Prefix
    

    Here, the annotation ingress.citrix.com/canary-weight: “10” is the annotation for the weight based canary. This annotation specifies the Citrix ingress controller to configure the Citrix ADC in such a way that 10 percent of the total requests destined to webapp.com is sent to the guestbook-canary service. This is the service for the canary version of the Guestbook application.

Um den HTTP-Header-basierten Canary mit Citrix Ingress Controller bereitzustellen, ersetzen Sie die Canary-Anmerkung ingress.citrix.com/canary-weight: durch die Anmerkung ingress.citrix.com/canary-by-header: in der Datei canary-ingress.yaml.

Um den auf HTTP-Header-Wert basierenden Canary mit Citrix Ingress Controller bereitzustellen, ersetzen Sie die Anmerkung ingress.citrix.com/canary-weight: durch die Anmerkungen ingress.citrix.com/canary-by-header: und ingress.citrix.com/canary-by-header-value: in der Datei canary-ingress.yaml.

Hinweis:

Sie können die Canary-Beispiel-YAMLs für das Erreichen von Canary basierend auf Header und Canary basierend auf

Bereitstellung der Citrix ADC-integrierten Canary-Bereitstellungslösung