Apigee in Google Distributed Cloud mit Air Gap installieren

In diesem Leitfaden wird beschrieben, wie Sie Apigee Edge für Private Cloud und API-Proxys in einer GDC-Umgebung (Google Distributed Cloud) ohne Internetverbindung installieren und bereitstellen. GDC-Angebote mit Air Gap, einschließlich Apigee Edge for Private Cloud, erfordern keine Verbindung zu Google Cloud, um Infrastruktur und Dienste zu verwalten. Sie können für alle Vorgänge eine lokale Steuerungsebene verwenden, die in Ihren Räumlichkeiten gehostet wird. Eine Übersicht über GDC mit Air Gap finden Sie hier.

Dieser Leitfaden richtet sich an Apigee-Operatoren, die mit Apigee Edge for Private Cloud vertraut sind und grundlegende Kenntnisse in Kubernetes haben.

Erforderliche Schritte

Damit der Operator Apigee Edge for Private Cloud in einer GDC-Umgebung ohne Internetverbindung installieren und bereitstellen kann, muss er die folgenden Schritte ausführen:

Hinweis

Bevor Sie mit der Installation beginnen, müssen Sie die folgenden Schritte ausführen:

  1. Erstellen Sie ein GDC-Projekt für die Installation, falls Sie noch keines haben. Weitere Informationen finden Sie unter Projekt erstellen.
  2. Laden Sie die gdcloud-CLI auf einer mit GDC verbundenen Workstation oder in der Continuous Deployment-Umgebung Ihrer Organisation herunter, installieren Sie sie und konfigurieren Sie sie.
  3. Rufen Sie die Anmeldedaten ab, die für die Verwendung der gdcloud CLI und der kubectl API erforderlich sind. Hier finden Sie die erforderlichen Schritte.
  4. Bestätigen Sie den Apigee-Nutzernamen und das Passwort, die Sie von Ihrem Apigee-Kundenbetreuer erhalten haben.
  5. Bestätigen Sie den Namen Ihres GKE-Administratorclusters und den Namen Ihres GKE-Nutzerclusters.

Kapazitätsanforderungen

Für die Installation von Apigee Edge for Private Cloud auf GDC sind mehrere VMs mit bestimmten Ressourcenzuweisungen erforderlich. Für diese VMs fallen Gebühren basierend auf ihren Rechenressourcen (RAM, vCPU-Kerne) und dem lokalen Festplattenspeicher an. Weitere Informationen finden Sie unter Preise.

In der folgenden Tabelle sind die Ressourcenanforderungen für jede VM aufgeführt:

VM-Typ RAM vCPU-Kerne Festplattenspeicher
Repository-Knoten 8 GB 2 vCPU-Kerne 64 GB
Kontrollknoten 8 GB 2 vCPU-Kerne 64 GB
Apigee API-Verwaltungsknoten 1, 2 und 3 16 GB RAM 8 vCPU-Kerne 670 GB
Apigee API-Verwaltungsknoten 4 und 5 16 GB RAM 8 vCPU-Kerne 500 GB bis 1 TB

Rollen und Berechtigungen

Die folgenden Rollen und Berechtigungen sind erforderlich, um Apigee Edge for Private Cloud in einer GDC-Umgebung ohne Internetverbindung bereitzustellen:

  • Plattformadministrator: Weisen Sie die Rolle IAM Admin zu.
  • Anwendungsoperator (AO): Weisen Sie die folgenden Rollen zu:
    • Harbor Instance Admin: Hat vollen Zugriff auf die Verwaltung von Harbor-Instanzen in einem Projekt.
    • LoggingTarget Creator: Erstellt benutzerdefinierte LoggingTarget-Ressourcen im Projekt-Namespace.
    • LoggingTarget Editor: Bearbeitet benutzerdefinierte LoggingTarget-Ressourcen im Projekt-Namespace.
    • Project Bucket Admin: Verwaltet die Storage-Buckets und Objekte in Buckets.
    • Project Grafana Viewer: Greift auf die Monitoring-Instanz im Projekt-Namespace zu.
    • Project NetworkPolicy Admin: Verwaltet die Projektnetzwerkrichtlinien im Projekt-Namespace.
    • Project VirtualMachine Admin: Verwaltet die VMs im Projekt-Namespace.
    • Secret Admin: Verwaltet Kubernetes-Secrets in Projekten.
    • Service Configuration Admin: Hat Lese- und Schreibzugriff auf Dienstkonfigurationen in einem Projektnamespace.
    • Namespace Admin: Verwaltet alle Ressourcen in Projekt-Namespaces.

    • Weitere Informationen zum Zuweisen von GDC-Rollen und -Berechtigungen für Air-Gap-Umgebungen finden Sie unter Zugriff erteilen und entziehen.

    Beschränkungen

    Für Apigee auf GDC Air-Gapped gelten die folgenden Einschränkungen:

    • Apigee auf GDC Air-Gapped wird nicht mit DNS-Servern geliefert und verwendet die lokale DNS-Auflösung als Workaround. Wenn Apigee on GDC air-gapped in einer Umgebung mit externen DNS-Servern bereitgestellt wird, ersetzen Sie die Schritte, mit denen das lokale DNS konfiguriert wird, durch die Konfiguration von DNS-Einträgen auf den DNS-Servern.
    • Apigee auf GDC Air-Gapped enthält keinen eigenständigen SMTP-Server. Sie können jederzeit einen SMTP-Server konfigurieren, um ausgehende E-Mail-Benachrichtigungen für die Kontoerstellung und das Zurücksetzen von Passwörtern über den Management Server und die Management-UI zu aktivieren. Verwaltungs-APIs sind weiterhin für die Verwaltung von Apigee-Nutzerkonten verfügbar. Weitere Informationen finden Sie unter Edge-SMTP-Server konfigurieren.
    • Bei der Air-Gap-Implementierung von Apigee auf GDC werden keine Einbruchserkennung und ‑vermeidung implementiert. Installieren und konfigurieren Sie ein Intrusion Prevention System (IPS), z. B. Snort, um schädliche Aktivitäten zu erkennen und zu verhindern.

    Erforderliche Dateien abrufen

    Um die Installationsdateien zu erhalten, müssen Sie zuerst einen verbundenen Knoten einrichten und dann die Dateien herunterladen.

    Verbundene Knoten einrichten

    Der verbundene Knoten ist eine einzelne VM außerhalb von GDC, die Sie zum Herunterladen der Installationsdateien verwenden. Für diese VM ist Internetzugriff erforderlich und sie wird nur für den Installationsprozess verwendet.

    Für den verbundenen Knoten sind folgende Kapazität und Konfiguration erforderlich:

    • Betriebssystem:Rocky Linux 8
    • Maschinengröße:8 GB RAM, 2 vCPU-Kerne, 64 GB lokaler Festplattenspeicher
    • Konnektivität:
      • Eingehend:TCP 22 (SSH)
      • Ausgehend:Internet

    Folgen Sie der Anleitung unter VM-Instanz erstellen und starten, um den verbundenen Knoten zu erstellen. Nachdem die VM erstellt wurde, folgen Sie der Anleitung unter Verbindung zu Linux-VMs herstellen. um eine Verbindung zur VM herzustellen. Eine Liste der unterstützten Betriebssysteme finden Sie unter Von GDC unterstützte Betriebssysteme.

    Installationsdateien herunterladen

    So laden Sie die Installationsdateien herunter:

    1. In den Versionshinweisen zu Apigee Edge for Private Cloud finden Sie die neueste offizielle Releaseversion, die für GDC unterstützt wird. Sie ist in der Spalte „Edge for Private Cloud“ angegeben.
    2. Laden Sie die Edge-Einrichtungsdatei herunter: 
      curl https://software.apigee.com/apigee/tarball/VERSION/rocky8/archive.tar -o /tmp/archive.tar -u 'APIGEE_USER:APIGEE_PASSWORD'

      Wobei:

      • APIGEE_USER ist der Nutzername, den Sie für die Apigee-Organisation erhalten haben.
      • APIGEE_PASSWORD ist das Passwort, das Sie für die Apigee-Organisation erhalten haben.
      • VERSION ist die Apigee Edge for Private Cloud-Releaseversion für die Verwendung auf GDC, die Sie installieren möchten, z. B. 4.53.01.
    3. Laden Sie die aktuelle bootstrap_VERSION.sh-Datei für Apigee Edge for Private Cloud in /tmp/bootstrap_VERSION.sh herunter: 
      curl https://software.apigee.com/bootstrap_VERSION.sh -o /tmp/bootstrap_VERSION.sh

      Dabei ist VERSION die neueste Apigee Edge for Private Cloud-Releaseversion für die Verwendung auf GDC, die Sie installieren möchten, z. B. 4.53.01.

    4. Installieren Sie das Edge-Dienstprogramm apigee-service und die Abhängigkeiten: 
      sudo bash /tmp/bootstrap_VERSION.sh apigeeuser=APIGEE_USER apigeepassword=APIGEE_PASSWORD

      Wobei:

      • APIGEE_USER ist der Nutzername, den Sie für die Apigee-Organisation erhalten haben.
      • APIGEE_PASSWORD ist das Passwort, das Sie für die Apigee-Organisation erhalten haben.
      • VERSION ist die Apigee Edge for Private Cloud-Releaseversion für die Verwendung in GDC, die Sie installieren möchten.

    5. Führen Sie das Setupscript auf dem verbundenen Knoten aus: 
      chmod a+x connected-node_setup.sh \
  ./connected-node_setup.sh

      In diesem Schritt generiert das Skript die erforderlichen Dateien an den folgenden Speicherorten (z. B. für Version 4.53.01):

      • /opt/apigee/data/apigee-mirror/apigee-4.53.01.tar.gz
      • /tmp/apigee-nginx/apigee-nginx.tar
      • /tmp/fluentbit/fluentbit.tar
      • /tmp/postgresql14/postgresql14.tar
      • /tmp/ansible-rpms.tar
      • /tmp/apigee-repos.tar
    6. Übertragen Sie die erforderlichen Dateien vom verbundenen Knoten über SSH auf einen lokalen Computer: 
      mkdir apigee-files
cd apigee-files
for file in /opt/apigee/data/apigee-mirror/apigee-4.53.01.tar.gz /tmp/ansible-rpms.tar /tmp/apigee-nginx/apigee-nginx.tar /tmp/fluentbit/fluentbit.tar /tmp/postgresql14/postgresql14.tar /tmp/apigee-repos.tar; do
  scp -i SSH_PRIVATE_KEY_FILE USER@CONNECTED_NODE_IP:$file .
  done

      Wobei:

      • SSH_PRIVATE_KEY_FILE ist der Pfad zur privaten SSH-Schlüsseldatei.
      • USER ist der Nutzername für den verbundenen Knoten.
      • CONNECTED_NODE_IP ist die IP-Adresse des verbundenen Knotens.

    Storage-Bucket einrichten

    In diesem Schritt richtet der GDC-Operator einen Speicher-Bucket im GDC-Projekt ein, in dem Apigee Edge for Private Cloud-Sicherungsdateien gespeichert werden.

    Storage-Bucket erstellen

    So erstellen Sie einen Storage-Bucket im GDC-Projekt:

    1. Authentifizieren Sie sich beim Administratorcluster der Organisation: 
      gdcloud auth login --login-config-cert WEB_TLS_CERT
gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      Wobei:

      • WEB_TLS_CERT ist der Pfad zum Web-TLS-Zertifikat.
      • ORG_ADMIN_CLUSTER ist der Name des GKE-Clusters des Organisationsadministrators.

    2. Legen Sie die Umgebungsvariablen für das Projekt und den Bucket fest: 
      export PROJECT=PROJECT
export BUCKET=BUCKET_NAME

      Wobei:

      • PROJECT ist der Name Ihres GDC-Projekts.
      • BUCKET_NAME ist der Name des Buckets, den Sie zum Speichern von Sicherungsdateien für Apigee Edge for Private Cloud erstellen möchten.
    3. Wenden Sie die Bucket-Konfiguration an: 
      kubectl apply -f - <<EOF
apiVersion: object.GDC.goog/v1
kind: Bucket
metadata:
  name: $BUCKET
  namespace:$PROJECT
spec:
  description: bucket for Apigee backup files
  storageClass: Standard
  bucketPolicy :
    lockingPolicy :
      defaultObjectRetentionDays: 30
EOF

      Mit dieser Konfiguration wird ein Bucket mit einer Aufbewahrungsdauer von 30 Tagen erstellt.

    Bucket-Zugriff konfigurieren

    So konfigurieren Sie den Zugriff auf den Speicher-Bucket:

    1. Erstellen Sie ein Dienstkonto im Projekt: 
      gdcloud iam service-accounts create $BUCKET-sa \
    --project=$PROJECT
    2. Erstellen Sie die Rolle und die Rollenbindung, um ein Secret für den Zugriff auf den Bucket zu generieren: 
      kubectl apply -f - <<EOF
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: $BUCKET-role
  namespace: $PROJECT
rules:
-   apiGroups:
  -   object.gdc.goog
  resourceNames:
  -   $BUCKET
  resources:
  -   buckets
  verbs:
  -   get
  -   read-object
  -   write-object
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: $BUCKETrolebinding
  namespace: $PROJECT
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: $BUCKET-role
subjects:
-   kind: ServiceAccount
  name: $BUCKET-sa
  namespace: $PROJECT
EOF
    3. Rufen Sie die Zugriffsschlüssel-ID und den Schlüssel aus dem Secret ab: 
      export BUCKET_SECRET=$(kubectl get secret -n $PROJECT -o jsonpath="{range .items[*]}{.metadata.name}{':'}{.metadata.annotations['object\.GDC\.goog/subject']}{'\n'}{end}" | grep $BUCKET | tail -1 | cut -f1 -d :)
echo "access-key-id=$(kubectl get secret -n $PROJECT $BUCKET_SECRET -o jsonpath="{.data['access-key-id']}")"
echo "access-key=$(kubectl get secret -n $PROJECT $BUCKET_SECRET -o jsonpath="{.data['secret-access-key']}")"

      Die Ausgabe sollte in etwa so aussehen: 

      access-key-id=RFdJMzRROVdWWjFYNTJFTzJaTk0=
access-key=U3dSdm5FRU5WdDhMckRMRW1QRGV0bE9MRHpCZ0Ntc0cxVFJQdktqdg==
    4. Erstellen Sie ein Secret, das vom Uploader im GKE-Nutzercluster verwendet werden soll:
      1. Authentifizieren Sie sich beim GKE-Nutzercluster: 
        gdcloud clusters get-credentials USER_CLUSTER

        Dabei ist USER_CLUSTER der Name des GKE-Nutzerclusters.

      2. Wenden Sie die Secret-Konfiguration an: 
        kubectl apply -f - <<EOF
apiVersion: v1
kind: Secret
metadata:
  namespace: $PROJECT
  name: $BUCKET-secret
type: Opaque
data:
  access-key-id: ACCESS_KEY_ID
  access-key: ACCESS_KEY
EOF

        Wobei:

        • ACCESS_KEY_ID ist die im vorherigen Schritt abgerufene Zugriffsschlüssel-ID.
        • ACCESS_KEY ist der im vorherigen Schritt abgerufene Zugriffsschlüssel.
    5. Rufen Sie den Speicherendpunkt, den vollqualifizierten Domainnamen (FQDN) und die Region des Buckets ab:
      1. Authentifizieren Sie sich beim Administratorcluster der Organisation: 
        gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

        Dabei ist ORG_ADMIN_CLUSTER der Name des GKE-Clusters des Organisationsadministrators.

      2. Rufen Sie den Speicherendpunkt, den vollqualifizierten Domainnamen (FQDN) und die Region des Buckets ab: 
        kubectl get buckets ${BUCKET} -n $PROJECT -o jsonpath="{'endpoint: '}{.status.endpoint}{'\n'}{'bucket: '}{.status.fullyQualifiedName}{'\n'}{'region: '}{.status.region}{'\n'}"

        Die Ausgabe sollte in etwa so aussehen:

        endpoint: https://objectstorage.gpu-org.cookie.sesame.street
bucket: ez9wo-apigee-backup-bucket
region: cookie
    6. Aktualisieren Sie die folgenden Werte in der Datei apigee/helm_user_cluster/values-cookie-air-gapped.yaml: 
      objectstorekeyname: "apigee-backup-bucket-secret"
objectstoreurl: "BUCKET_ENDPOINT"
objectstorebucket: "BUCKET_FQDN"

      Wobei:

      • BUCKET_ENDPOINT ist der Endpunkt des Buckets, der im vorherigen Schritt abgerufen wurde.
      • BUCKET_FQDN ist der vollständig qualifizierte Domainname des Buckets, den Sie im vorherigen Schritt erhalten haben.

    Repository-Knoten einrichten

    In diesem Schritt richtet der GDC-Operator einen Repository-Knoten ein, auf dem das Spiegel-Repository für Apigee Edge for Private Cloud gehostet wird.

    Repository-Knoten erstellen

    So erstellen Sie einen Repository-Knoten:

    1. Aktualisieren Sie apigee/helm_user_cluster/values-cookie-air-gapped.yaml so: 
      repo_node:
  enabled: true

apigee_node:
  enabled: false

control_node:
  enabled: false

      Achten Sie darauf, dass repo_node aktiviert ist und sowohl apigee_node als auch control_node deaktiviert sind. Diese Knoten werden in einem späteren Schritt bereitgestellt.

    2. Anmeldedaten für den Administrator-Cluster der Organisation abrufen: 
      gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      Dabei ist ORG_ADMIN_CLUSTER der Name des GKE-Clusters des Organisationsadministrators.

    3. Erstellen Sie eine virtuelle Python-Umgebung: 
      python3 -m venv venv /
source venv/bin/activate
    4. Führen Sie das Bereitstellungsskript aus, um den Repository-Knoten zu erstellen: 
      python apigee/solution_deploy.py gdc-air-gapped

    Knotenzugriff auf Repository konfigurieren

    So konfigurieren Sie den Zugriff auf den Repository-Knoten:

    1. Konfigurieren Sie SSH für den Repository-Knoten: 
      export NODE=repo
kubectl create -n $PROJECT -f - <<EOF
  apiVersion: virtualmachine.GDC.goog/v1
  kind: VirtualMachineAccessRequest
  metadata:
    generateName: $NODE-
  spec:
    ssh:
      key: |
        "cat SSH_PUBLIC_KEY_FILE"
  ttl: 24h
  user: admin
  vm: $NODE
  EOF

      Dabei ist SSH_PUBLIC_KEY_FILE der Name der Datei, die Ihren öffentlichen SSH-Schlüssel enthält.

    2. Rufen Sie die externe IP-Adresse für den Repository-Knoten ab: 
      kubectl get virtualmachineexternalaccess -n $PROJECT $NODE -ojsonpath='{.status.ingressIP}'
    3. Rufen Sie die interne IP-Adresse für den Repository-Knoten ab: 
      kubectl get virtualmachines.virtualmachine.gdc.goog -n $PROJECT $NODE -ojsonpath='{.status.network.interfaces[1].ipAddresses[0]}'

    Installationsdateien hochladen

    In diesem Schritt lädt der GDC-Operator die neueste Version der folgenden Dateien auf den Repository-Knoten hoch:

    • apigee-4.53.01
    • apigee-nginx.tar
    • postgresql14.tar
    • fluentbit.tar
    • ansible-rpms.tar
    • apigee-repos.tar

    So laden Sie die Installationsdateien hoch:

    1. Kopieren Sie die private SSH-Schlüsseldatei auf den Repository-Knoten: 
      scp -i SSH_PRIVATE_KEY_FILE ~/apigee-files/* admin@REPO_EXTERNAL_IP:/tmp

      Wobei:

      • SSH_PRIVATE_KEY_FILE ist der Name der Datei, die Ihren privaten SSH-Schlüssel enthält.
      • REPO_EXTERNAL_IP ist die externe IP-Adresse des Repository-Knotens, die Sie im vorherigen Schritt abgerufen haben.
    2. Laden Sie den Ordner mit den Fluent Bit-Konfigurationen in den Repository-Knoten hoch: 
      scp -i SSH-PRIVATE-KEY-FILE -r apigee/scripts/fluent-bit admin@REPO_EXTERNAL_IP:/tmp/fluent-bit

      Wobei:

      • SSH_PRIVATE_KEY_FILE ist der Name der Datei, die Ihren privaten SSH-Schlüssel enthält.
      • REPO_EXTERNAL_IP ist die externe IP-Adresse des Repository-Knotens.

    Spiegel-Repository konfigurieren

    So konfigurieren Sie das Spiegel-Repository:

    1. Kopieren Sie apigee/scripts/repo_setup.sh auf den Repository-Knoten.
    2. Ersetzen Sie im Skript REPO_USER und REPO_PASSWORD durch den gewünschten Nutzernamen und das gewünschte Passwort für das Spiegel-Repository.
    3. Führen Sie das Skript aus: 
      chmod a+x repo_setup.sh
./repo_setup.sh

      Wenn ein No such file or directory-Fehler auftritt, führen Sie das Skript noch einmal aus.

    4. Testen Sie die Verbindung zum Spiegel-Repository lokal vom Repository-Knoten aus. 
      curl http://REPO_USER:REPO_PASSWORD@REPO_INTERNAL_IP:3939/bootstrap_VERSION.sh -o /tmp/bootstrap_VERSION.sh
curl http://REPO_USER:REPO_PASSWORD@REPO_INTERNAL_IP:3939/apigee/release/VERSION/repodata/repomd.xml

      Ersetzen Sie VERSION durch die Version von Apigee Edge for Private Cloud, die Sie installieren möchten.

    Apigee-Knoten bereitstellen

    In diesem Schritt stellt der GDC-Operator die Apigee API-Verwaltungsknoten bereit.

    Apigee-Knoten erstellen

    So erstellen Sie die Apigee API-Verwaltungsknoten:

    1. Ersetzen Sie REPO_INTERNAL_IP, REPO_USER_NAME und REPO_PASSWORD in apigee/helm/scripts/apigee_setup.sh durch die gewünschten Werte.
    2. Exportieren Sie die Werte als Umgebungsvariablen: 
      export REPO_IP=REPO_INTERNAL_IP
export REPO_USER=REPO_USER_NAME
export REPO_PASSWORD=REPO_PASSWORD
    3. Aktivieren Sie apigee_node in apigee/helm/values-cookie-air-gapped.yaml wie unten gezeigt: 
      apigee_node:
  enabled: true
    4. Führen Sie das Bereitstellungsskript aus, um die Apigee-Knoten zu erstellen: 
        source venv/bin/activate
  python apigee/solution_deploy.py gdc-air-gapped

    Apigee-Knotenzugriff konfigurieren

    Zugriff auf die Apigee API-Verwaltungsknoten konfigurieren:

    1. Authentifizieren Sie sich beim Administratorcluster der Organisation: 
      gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      Dabei ist ORG_ADMIN_CLUSTER der Name des GKE-Clusters des Organisationsadministrators.

    2. Erstellen Sie einen SSH-Schlüssel für jeden Knoten: 
      for i in 1 2 3 4 5; do
  kubectl create -n $PROJECT -f - <<EOF
  apiVersion: virtualmachine.GDC.goog/v1
  kind: VirtualMachineAccessRequest
  metadata:
    generateName: node$i
  spec:
    ssh:
      key: |
        "cat SSH_PUBLIC_KEY_FILE"
  ttl: 24h
  user: admin
  vm: node$i
  EOF
  done

      Dabei ist SSH_PUBLIC_KEY_FILE der Name der Datei, die Ihren öffentlichen SSH-Schlüssel enthält.

    3. Rufen Sie die externen IP-Adressen für die Apigee-Knoten ab: 
      for i in 1 2 3 4 5; do
  kubectl get virtualmachineexternalaccess -n $PROJECT node$i -ojsonpath='{.status.ingressIP}'
  echo
  done
    4. Rufen Sie die internen IP-Adressen für die Apigee-Knoten ab: 
      for i in 1 2 3 4 5; do
  kubectl get virtualmachines.virtualmachine.gdc.goog -n $PROJECT node$i -ojsonpath='{.status.network.interfaces[1].ipAddresses[0]}'
  echo
  done
    5. Optional: Prüfen Sie, ob die Startskripts auf den Apigee-Knoten erfolgreich ausgeführt wurden:
      1. Stellen Sie eine SSH-Verbindung zum Knoten her und führen Sie den folgenden Befehl aus: 
        sudo journalctl -u cloud-final -f
      2. Suchen Sie nach Logs wie den folgenden: 
        Aug 29 18:17:00 172.20.128.117 cloud-init[1895]: Complete!
Aug 29 18:17:00 172.20.128.117 cloud-init[1895]: Finished running the command: . /var/lib/google/startup-scripts/apigee-setup

    Steuerknoten einrichten

    In diesem Schritt richtet der GDC-Operator einen Steuerknoten ein, um Apigee-Installationen zu verwalten.

    Kontrollknoten erstellen

    So erstellen Sie einen Kontrollknoten:

    1. Ersetzen Sie REPO_INTERNAL_IP, REPO_USER_NAME und REPO_PASSWORD in apigee/helm/scripts/control_setup.sh durch die gewünschten Werte.
    2. Aktivieren Sie control_node in apigee/helm/values-cookie-air-gapped.yaml wie gezeigt: 
      control_node:
  enabled: true
    3. Führen Sie das Bereitstellungsskript aus, um den Steuerknoten zu erstellen: 
      source venv/bin/activate
python apigee/solution_deploy.py gdc-air-gapped

    Zugriff auf Steuerknoten konfigurieren

    So konfigurieren Sie den Zugriff auf den Steuerknoten:

    1. Konfigurieren Sie den SSH-Zugriff auf den Steuerknoten: 
      kubectl create -n $PROJECT -f - <<EOF
apiVersion: virtualmachine.GDC.goog/v1
kind: VirtualMachineAccessRequest
metadata:
  generateName: control-
spec:
  ssh:
    key: |
      "cat SSH_PUBLIC_KEY_FILE"
ttl: 24h
user: admin
vm: control
EOF
    2. Rufen Sie die externe IP-Adresse für den Kontrollknoten ab: 
      kubectl get virtualmachineexternalaccess -n $PROJECT control -ojsonpath='{.status.ingressIP}'
    3. Rufen Sie die interne IP-Adresse für den Kontrollknoten ab: 
      kubectl get virtualmachines.virtualmachine.GDC.goog -n $PROJECT control -ojsonpath='{.status.network.interfaces[1].ipAddresses[0]}'

    Ansible konfigurieren

    In diesem Schritt richtet der GDC-Operator die -Umgebung auf dem Steuerknoten ein.

    So konfigurieren Sie die Ansible-Umgebung:

    1. Stellen Sie eine SSH-Verbindung zum Steuerknoten her und richten Sie die Ansible-Umgebung ein: 
      cd /home/admin
cp -r /tmp/apigee-repos .
cd apigee-repos/ansible-opdk-accelerator/setup
    2. Ersetzen Sie Remote-Git-Repositories durch eine lokale Datei: 
      sed -i 's/https:\/\/github.com\/carlosfrias/git+file:\/\/\/home\/admin\/apigee-repos/g'  requirements.yml
sed -i 's/\.git$//g'  requirements.yml
    3. Install Ansible requirements: 
        sudo chown -R admin /home/admin/apigee-repos
  ansible-galaxy install -r requirements.yml -f
    4. Aktualisieren Sie die Einrichtungskonfiguration:
      1. Bearbeiten Sie die Datei main.yml. 
        vi ~/apigee-repos/ansible-opdk-accelerator/setup/roles/apigee-opdk-setup-ansible-controller/tasks/main.yml
      2. Entfernen Sie die Aufgaben, für die GitHub-Zugriff erforderlich ist:
        • Git-SSH-Checkout von Konfigurations-Repositories
        • Git-HTTPS-Checkout von Konfigurations-Repositories
      3. Führen Sie das Setup-Playbook aus: 
        cd ~/apigee-repos/ansible-opdk-accelerator/setup
ansible-playbook setup.yml
    5. Laden Sie den SSH-Schlüssel für die Apigee-Knoten auf den Steuerknoten hoch: 
      scp -i CONTROL_SSH_PRIVATE_KEY_FILE APIGEE_NODE_SSH_PRIVATE_KEY_FILE admin@CONTROL_EXTERNAL_IP:/home/admin/.ssh/id_rsa

      Wobei:

      • CONTROL_SSH_PRIVATE_KEY_FILE ist der Name der Datei, die den privaten SSH-Schlüssel Ihres Kontrollknotens enthält.
      • APIGEE_NODE_SSH_PRIVATE_KEY_FILE ist der Name der Datei, die den privaten SSH-Schlüssel Ihres Apigee-Knotens enthält.
      • CONTROL_EXTERNAL_IP ist die externe IP-Adresse des Steuerknotens.
    6. Erstellen Sie die Ansible-Inventarkonfigurationsdatei:
      1. Kopieren Sie den Inhalt der Datei apigee/scripts/ansible/prod.cfg in die Datei prod.cfg: 
        vi ~/.ansible/multi-planet-configurations/prod.cfg
      2. Erstellen Sie den Ordner edge-dc1 und kopieren Sie den Inhalt der Datei apigee/scripts/ansible/edge-dc1 in die Datei edge-dc1: 
        mkdir ~/.ansible/inventory/prod
vi ~/.ansible/inventory/prod/edge-dc1
    7. Aktualisieren Sie die internen IP-Adressen von Apigee-Knoten in edge-dc1: 
      apigee_000 ansible_host=APIGEE_NODE1_INTERNAL_IP
apigee_001 ansible_host=APIGEE_NODE2_INTERNAL_IP
apigee_002 ansible_host=APIGEE_NODE3_INTERNAL_IP
apigee_003 ansible_host=APIGEE_NODE4_INTERNAL_IP
apigee_004 ansible_host=APIGEE_NODE5_INTERNAL_IP

      Dabei sind die Werte für APIGEE_NODE*_INTERNAL_IP die internen IP-Adressen der Apigee-Knoten, die Sie in einem früheren Schritt abgerufen haben.

    8. Konfigurieren Sie die ~/.apigee-secure/credentials.yml-Datei mit den folgenden Werten:
      • apigee_repo_user: 'APIGEE_REPO_USER'
      • apigee_repo_password: 'APIGEE_REPO_PASSWORD'
      • opdk_qpid_mgmt_username: 'OPDK_QPID_MGMT_USERNAME'
      • opdk_qpid_mgmt_password: 'OPDK_QPID_MGMT_PASSWORD'

      Wobei:

      • APIGEE_REPO_USER ist der Nutzername für das Apigee-Repository.
      • APIGEE_REPO_PASSWORD ist das Passwort für das Apigee-Repository.
      • OPDK_QPID_MGMT_USERNAME ist der Nutzername für den Apigee QPID-Verwaltungsserver.
      • OPDK_QPID_MGMT_PASSWORD ist das Passwort für den Apigee QPID-Verwaltungsserver.

    9. Fügen Sie eine Lizenzdatei mit einer gültigen Apigee Edge for Private Cloud-Lizenzdatei hinzu. Der Name der Datei muss license.txt lauten.
    10. Kopieren Sie den Inhalt der Datei ~/.apigee-secure/license.txt in die Datei license.txt, die Sie gerade erstellt haben.
    11. Konfigurieren Sie die folgenden Werte in der Datei ~/.apigee/custom-properties.yml:
      • opdk_version: 'OPDK_VERSION'
      • apigee_repo_url: 'APIGEE_REPO_URL'

      Wobei:

      • OPDK_VERSION ist die Version von Apigee Edge for Private Cloud, die Sie installieren möchten.
      • APIGEE_REPO_URL ist die URL des Apigee-Repositorys.

    12. Exportieren Sie die Konfigurationsdatei als Umgebungsvariable: 
      export ANSIBLE_CONFIG=~/.ansible/multi-planet-configurations/prod.cfg

    Apigee-Komponenten installieren

    In diesem Schritt installiert der GDC-Operator die Apigee-Komponenten mit Ansible.

    So installieren Sie die Apigee-Komponenten:

    1. Ersetzen Sie die Remote-Git-Repositories durch lokale Dateien: 
      cd ~/apigee-repos/ansible-opdk-accelerator/installations/multi-node/
sed -i 's/https:\/\/github.com\/carlosfrias/git+file:\/\/\/home\/admin\/apigee-repos/g' requirements.yml
sed -i 's/\.git$//g'  requirements.yml
    2. Installieren Sie die Ansible-Anforderungen: 
      ansible-galaxy install -r requirements.yml -f
    3. Patchen Sie die Ansible-Rollen: 
      sed -i 's/private_address/inventory_hostname/g' ~/.ansible/roles/apigee-opdk-settings-cassandra/tasks/main.yml
sed -i 's/include/include_tasks/g' ~/.ansible/roles/apigee-opdk-server-self/tasks/main.yml
sed -i 's/include/include_tasks/g' ~/.ansible/roles/apigee-opdk-setup-silent-installation-config/tasks/main.yml
cat << EOF >> ~/.ansible/roles/apigee-opdk-setup-silent-installation-config/templates/response-file-template.conf.j2
QPID_MGMT_USERNAME= opdk_qpid_mgmt_username
QPID_MGMT_PASSWORD= opdk_qpid_mgmt_password
EOF
sed -i 's/mode: 0700/mode: 0700\n      recurse: yes/g' ~/.ansible/roles/apigee-opdk-setup-postgres-config/tasks/main.yml
    4. Ersetzen Sie den Inhalt der Datei install.yml durch den Inhalt von apigee/scripts/ansible/install.yml.
    5. Führen Sie das Playbook aus, um die Apigee-Komponenten zu installieren: 
      ansible-playbook install.yml
    6. Deaktivieren Sie den Link zum Zurücksetzen des Passworts des Nutzers in der Edge-Benutzeroberfläche. Apigee in einer Air-Gap-Umgebung von GDC enthält keinen SMTP-Server. Folgen Sie der Anleitung unter Link zum Zurücksetzen des Passworts in der Edge-Benutzeroberfläche deaktivieren.

    Pods und Dienste bereitstellen

    In diesem Schritt stellen Sie die Uploader-, Reverse-Proxy-, Load-Balancer- und Logging-Pods und -Dienste bereit.

    So stellen Sie die Pods und Dienste bereit:

    1. Folgen Sie der Anleitung unter Harbor-Registrierungsinstanzen erstellen, um eine Harbor-Instanz im GDC-Projekt dev-apigee zu erstellen.
    2. Folgen Sie der Anleitung unter Harbor-Projekte erstellen, um ein Harbor-Projekt mit dem Namen apigee zu erstellen.
    3. Folgen Sie der Anleitung unter Zugriffssteuerung konfigurieren, um die Zugriffssteuerung für das Harbor-Projekt einzurichten.
    4. Folgen Sie der Anleitung unter Bei Docker und Helm anmelden, um die Docker-Authentifizierung zu konfigurieren.
    5. Aktualisieren Sie die IP-Adressen in der Datei apigee/apigee_user_cluster.toml wie unten dargestellt: 
      mgmt-server-proxy = "APIGEE_NODE1_EXTERNAL_IP"
router-proxy1 = "APIGEE_NODE2_EXTERNAL_IP"
router-proxy2 = "APIGEE_NODE3_EXTERNAL_IP"

      Wobei:

      • APIGEE_NODE1_EXTERNAL_IP ist die externe IP-Adresse des Apigee-Knotens 1, die Sie in einem früheren Schritt abgerufen haben.
      • APIGEE_NODE2_EXTERNAL_IP ist die externe IP-Adresse des Apigee-Knotens 2, die Sie in einem früheren Schritt abgerufen haben.
      • APIGEE_NODE3_EXTERNAL_IP ist die externe IP-Adresse des Apigee-Knotens 3, die Sie in einem früheren Schritt abgerufen haben.

    6. Legen Sie die SSL-Zertifikatsdatei (server.crt) und die Schlüsseldatei (server.key) für die Konfiguration von HTTPS in den Ordnern apigee/mgmt-server-proxy und apigee/router-proxy ab.

      Verwenden Sie den folgenden Befehl, um selbst signierte Zertifikate zu generieren: 

      openssl req -newkey rsa:4096 -x509 -nodes -keyout server.key -new -out server.crt -subj "/CN=*.apigeetest.com" -sha256 -days 365
    7. Aktualisieren Sie den Wert von SSH-PASSWORD für den Root-Nutzer im Uploader-Container in der Datei apigee/uploader/Dockerfile: 
      RUN echo 'root:SSH_PASSWORD' | chpasswd
    8. Rufen Sie die Anmeldedaten für den Nutzercluster ab: 
      gdcloud clusters get-credentials USER_CLUSTER

      Dabei ist USER_CLUSTER der Name des GKE-Nutzerclusters.

    9. Führen Sie das Bereitstellungsskript aus, um die Pods und Dienste bereitzustellen: 
      source venv/bin/activate
python apigee/solution_deploy_user_cluster.py gdc-air-gapped
    10. Rufen Sie die externen IP-Adressen der Dienste ab: 
      kubectl get svc -n $PROJECT_ID

    IP-Adressen für Uploader und Fluent Bit-Forwarder aktualisieren

    In diesem Schritt aktualisieren Sie die Uploader- und Fluent Bit-Forwarder-IPs in den Backup- und Apigee-Einrichtungsskripten.

    1. Aktualisieren Sie SSH_PASSWORD, root und UPLOADER_EXTERNAL_IP in apigee/helm/scripts/backup_setup.sh: 
      sshpass -p SSH_PASSWORD scp -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null apigee-backup* root@UPLOADER_EXTERNAL_IP:/temp/

      Wobei:

      • SSH_PASSWORD ist das Passwort für den Root-Nutzer.
      • UPLOADER_EXTERNAL_IP ist die externe IP-Adresse des Uploader-Dienstes, die Sie in einem früheren Schritt abgerufen haben.

    2. FLUENTBIT_EXTERNAL_IP in apigee/helm/scripts/apigee_setup.sh aktualisieren: 
      export FLUENTBIT_EXTERNAL_IP=FLUENTBIT_EXTERNAL_IP

    Wenn Sie das Startscript aktualisieren, müssen Sie die Apigee-Knoten neu starten. So starten Sie die Knoten neu:

    1. Beenden Sie die VMs: 
      gdcloud clusters get-credentials ORG_ADMIN_CLUSTER
export PROJECT=dev-apigee
for i in 1 2 3 4 5; do
  gdcloud compute instances stop node$i --project $PROJECT
  done
    2. Stellen Sie das Helm-Diagramm noch einmal bereit: 
      python apigee/solution_deploy.py gdc-air-gapped
    3. Starten Sie die VMs: 
      for i in 1 2 3 4 5; do
  GDCloud compute instances start node$i --project $PROJECT
  done

    Apigee-Organisation einrichten

    In diesem Schritt wird die Apigee-Organisation vom GDC-Operator eingebunden, indem ein Setupskript auf node1 ausgeführt wird.

    So führen Sie das Onboarding der Apigee-Organisation durch:

    1. Aktualisieren Sie die folgenden Werte in apigee/scripts/apigee_org_setup.sh wie dargestellt. Aktualisieren Sie nach Bedarf weitere Parameter. 
      IP1=APIGEE_NODE1_INTERNAL_IP

VHOST_ALIAS="APIGEE_NODE2_EXTERNAL_IP:9001 APIGEE_NODE3_EXTERNAL_IP:9001"

      Wobei:

      • APIGEE_NODE1_INTERNAL_IP ist die interne IP-Adresse des Apigee-Knotens 1, die Sie in einem früheren Schritt abgerufen haben.
      • APIGEE_NODE2_EXTERNAL_IP ist die externe IP-Adresse des Apigee-Knotens 2, die Sie in einem früheren Schritt abgerufen haben.
      • APIGEE_NODE3_EXTERNAL_IP ist die externe IP-Adresse des Apigee-Knotens 3, die Sie in einem früheren Schritt abgerufen haben.

    2. Führen Sie das Skript auf node1 aus, um die Organisation einzubinden: 
      chmod a+x apigee_org_setup.sh
./apigee_org_setup.sh

    HTTP-Konnektivität testen

    In diesem Schritt testen Sie die HTTP-Konnektivität für die Management API und den API-Proxy.

    So testen Sie die HTTP-Konnektivität:

    1. Rufen Sie die externe IP-Adresse des apigee-elb-Dienstes ab: 
      gdcloud clusters get-credentials USER_CLUSTER
export PROJECT=dev-apigee
kubectl get svc apigee-elb -n $PROJECT

      Dabei ist USER_CLUSTER der Name des GKE-Nutzerclusters.

      Dieser Dienst fungiert als Endpunkt für die Edge-Benutzeroberfläche, die Management API und den API-Proxy.

    Management API testen

    Wenn Sie die Management API testen möchten, senden Sie eine HTTP-Anfrage an den Endpunkt: 

    curl -u "opdk@apigee.com:Apigee123!" "http://APIGEE_ELB_EXTERNAL_IP:8080/v1/o/ORG_NAME/e/ENV_NAME/provisioning/axstatus"

    Wobei:

    • APIGEE_ELB_EXTERNAL_IP ist die externe IP-Adresse des apigee-elb-Dienstes, die Sie in einem früheren Schritt abgerufen haben.
    • ORG_NAME ist der Name der Apigee-Organisation.
    • ENV_NAME ist der Name der Apigee-Umgebung.

    API-Proxy testen

    So testen Sie den API-Proxy:

    1. Melden Sie sich in der Edge-Benutzeroberfläche an.
    2. Klicken Sie auf der Seite API-Proxys auf Erstellen, um einen neuen API-Proxy zu erstellen.
    3. Geben Sie auf der Seite Proxydetails die folgenden Werte ein:
      • Proxytyp:Wählen Sie Kein Ziel aus.
      • Proxy name: ok
      • Basispfad: /ok
      • Ziel: http://APIGEE_ELB_EXTERNAL_IP:9001
    4. Klicken Sie auf Erstellen, um den API-Proxy zu erstellen.
    5. Senden Sie eine HTTP-Anfrage an /ok: 
      curl -i http://APIGEE_ELB_EXTERNAL_IP:9001/ok
    6. Bestätigen Sie, dass die Antwort 200 OK ist.

    TLS konfigurieren und HTTPS testen

    In diesem Schritt konfiguriert der GDC-Operator TLS (Transport Layer Security) für den API-Proxy, die Edge-UI und die Management API.

    TLS für den API-Proxy konfigurieren

    1. Folgen Sie der Anleitung unter Keystore/Truststore und Alias erstellen, um ein selbstsigniertes Zertifikat mit den folgenden Werten zu erstellen:
      • KeyStore:myTestKeystore
      • KeyAlias:myKeyAlias
      • Allgemeiner Name:apigeetest.com
    2. Führen Sie einen API-Aufruf aus, um den virtuellen Host mit dem Namen api.apigeetest.com zu erstellen: 
      curl -v -H "Content-Type:application/xml" \
  -u "opdk@apigee.com:Apigee123!" "http://APIGEE_ELB_EXTERNAL_IP:8080/v1/o/ORG_NAME/e//virtualhosts" \
  -d '<VirtualHost  name="secure">
      <HostAliases>
        <HostAlias>api.apigeetest.com</HostAlias>
      </HostAliases>
      <Interfaces/>
      <Port>9005</Port>
      <OCSPStapling>off</OCSPStapling>
      <SSLInfo>
        <Enabled>true</Enabled>
        <ClientAuthEnabled>false</ClientAuthEnabled>
        <KeyStore>myTestKeystore</KeyStore>
        <KeyAlias>myKeyAlias</KeyAlias>
      </SSLInfo>
    </VirtualHost>'

      Wobei:

      • APIGEE_ELB_EXTERNAL_IP ist die externe IP-Adresse des apigee-elb-Dienstes, die Sie in einem früheren Schritt abgerufen haben.
      • ORG_NAME ist der Name der Apigee-Organisation.
      • ENV_NAME ist der Name der Apigee-Umgebung, in der der virtuelle Host erstellt werden soll.
    3. Erstellen Sie einen API-Proxy mit dem sicheren virtuellen Host.
    4. Konfigurieren Sie auf den Routern die DNS-Auflösung für virtuelle Hosts: 
      echo '127.0.0.1 api.apigeetest.com' | sudo tee -a /etc/hosts
    5. Prüfen Sie, ob die virtuellen Hosts lokal funktionieren, indem Sie eine HTTPS-Anfrage an den Endpunkt senden: 
      curl https://api.apigeetest.com:9005/ok -v -k
    6. Konfigurieren Sie die DNS-Auflösung für den Endpunkt: 
      echo 'APIGEE_ELB_EXTERNAL_IP apigeetest.com' | sudo tee -a /etc/hosts

      Dabei ist APIGEE_ELB_EXTERNAL_IP die externe IP-Adresse des apigee-elb-Dienstes, die Sie in einem vorherigen Schritt ermittelt haben.

    7. Rufen Sie https://apigeetest.com/ok in einem Webbrowser auf und prüfen Sie, ob die Seite funktioniert.

    TLS für die Edge-Benutzeroberfläche konfigurieren

    So konfigurieren Sie TLS für die Edge-Benutzeroberfläche:

    1. Generieren Sie eine Keystore-Datei aus der SSL-Zertifikatsdatei und der Schlüsseldatei: 
      openssl pkcs12 -export -clcerts -in server.crt -inkey server.key -out keystore.pkcs12
keytool -importkeystore -srckeystore keystore.pkcs12 -srcstoretype pkcs12 -destkeystore keystore.jks -deststoretype jks
    2. Platzieren Sie die Keystore-Datei unter dem Apigee-Ordner auf node1: 
      scp -i SSH_PRIVATE_KEY_FILE keystore.jks admin@APIGEE_NODE1_EXTERNAL_IP:/home/admin/

      Wobei:

      • SSH_PRIVATE_KEY_FILE ist der Name der Datei, die den privaten SSH-Schlüssel Ihres Apigee-Knotens enthält.
      • APIGEE_NODE1_EXTERNAL_IP ist die externe IP-Adresse des Apigee-Knotens 1, die Sie in einem früheren Schritt abgerufen haben.

    3. Stellen Sie eine SSH-Verbindung zu node1 her und verschieben Sie die Keystore-Datei in den Apigee-Ordner: 
      sudo mv keystore.jks /opt/apigee/customer/application/
    4. Erstellen Sie die SSL-Konfigurationsdatei: 
      sudo vi /tmp/sslConfigFile
    5. Aktualisieren Sie den Wert von KEY-PASS-PHRASE wie unten dargestellt: 
      HTTPSPORT=9443
DISABLE_HTTP=n
KEY_ALGO=JKS
KEY_FILE_PATH=/opt/apigee/customer/application/keystore.jks
KEY_PASS=KEY_PASS_PHRASE
    6. SSL mit der Konfigurationsdatei konfigurieren: 
      sudo chown apigee:apigee /tmp/sslConfigFile
/opt/apigee/apigee-service/bin/apigee-service edge-ui configure-ssl -f /tmp/sslConfigFile
    7. DNS-Auflösung für die Edge-Benutzeroberfläche konfigurieren: 
      echo 'APIGEE_ELB_EXTERNAL_IP ui.apigeetest.com' | sudo tee -a /etc/hosts

      Dabei ist APIGEE_ELB_EXTERNAL_IP die externe IP-Adresse des apigee-elb-Dienstes, die Sie in einem vorherigen Schritt ermittelt haben.

    8. Rufen Sie https://ui.apigeetest.com:9443 in einem Webbrowser auf und prüfen Sie, ob die Seite funktioniert. Weitere Informationen finden Sie im Leitfaden.

    TLS für die Management API konfigurieren

    So konfigurieren Sie TLS für die Management API:

    1. Konfigurieren Sie den Eigentümer für die Keystore-Datei (verwenden Sie denselben wie für die Edge-Benutzeroberfläche): 
      sudo chown apigee:apigee /opt/apigee/customer/application/keystore.jks
    2. Erstellen Sie die Datei „properties“: 
      sudo vi /opt/apigee/customer/application/management-server.properties

      3. Ersetzen Sie den Wert von KEY_PASS_PHRASE durch das Keystore-Passwort, wie unten dargestellt: 

      conf_webserver_ssl.enabled=true
# Leave conf_webserver_http.turn.off set to false
# because many Edge internal calls use HTTP.
conf_webserver_http.turn.off=false
conf_webserver_ssl.port=8443
conf_webserver_keystore.path=/opt/apigee/customer/application/keystore.jks
# Enter the obfuscated keystore password below.
conf_webserver_keystore.password=KEY_PASS_PHRASE
    3. Starten Sie den Verwaltungsserver neu, damit die Änderungen wirksam werden: 
      /opt/apigee/apigee-service/bin/apigee-service edge-management-server restart
    4. Prüfen Sie, ob HTTPS lokal funktioniert: 
      curl -u "opdk@apigee.com:Apigee123!" "https://localhost:8443/v1/users" -k
    5. Rufen Sie im Client https://apigeetest.com:8443/v1/users im Browser auf. Geben Sie den Nutzernamen und das Passwort des Administrators ein, um zu bestätigen, dass die Anmeldedaten richtig konfiguriert sind.

    Nächste Schritte