Hinweis:

Dieses Tutorial erfordert Zugriff auf Oracle Cloud. Informationen zum Anmelden für einen kostenlosen Account finden Sie unter Erste Schritte mit Oracle Cloud Infrastructure Free Tier.
Es verwendet Beispielwerte für Oracle Cloud Infrastructure-Zugangsdaten, -Mandanten und -Compartments. Wenn Sie Ihre Übung abgeschlossen haben, ersetzen Sie diese Werte durch die Werte, die für Ihre Cloud-Umgebung spezifisch sind.

OCI DevOps-Pipelines für Apache Airflow erstellen und mit Helm bereitstellen

Einführung

Dies ist Teil einer sechsteiligen Tutorialreihe, die fünf zeigt, wie Sie ein temporäres Ressourcenset in einem OKE-Cluster mit Golang-Microservices bereitstellen, das die Verwendung von OCI SDK, OCI-CLI, Resource Manager, OCI DevOps und Helm darstellt, um Apache Airflow bereitzustellen und zu zerstören.

Zielsetzung

In diesem Tutorial erfahren Sie, wie Sie OCI DevOps-Pipelines für Apache Airflow erstellen und mit Helm bereitstellen.

Voraussetzungen

Abschluss des vorherigen Tutorials in diesem Lernpfad, Teil 4/6 - OCI DevOps-Pipelines zum Erstellen und Bereitstellen der Golang-Microservices erstellen

Aufgabe 1: DevOps-Artefakte für Apache Airflow erstellen

Bevor Sie die Build-Pipeline DevOps erstellen, müssen wir die Artefakte erstellen, die mit den Build-Ergebnissen (Helm-Package und Containerimage) verbunden werden.

Gehen Sie zu der OCI-Registry, die Sie für dieses Tutorial erstellt haben.

Gehen Sie zur Seite DevOps-Projekt, klicken Sie auf Artefakte und dann auf Artefakt hinzufügen. Füllen Sie die Informationen wie unten aus.

Kontext: Dies ist ein Kubernetes-Manifest, um einen Ingress für den Luftstrom zu implementieren.
Name: airflow-ingress
Typ: Kubernetes-Manifest
Artefaktquelle: Inline

Fügen Sie den Inhalt unten in das Feld Wert ein.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
 generation: 1
 name: airflow-ingress
 namespace: airflow
spec:
 ingressClassName: nginx
 rules:
 - host: ${APP_HOST}
   http:
     paths:
     - backend:
         service:
           name: airflow-web
           port:
             number: 8080
       path: /
       pathType: ImplementationSpecific

Wiederholen Sie Schritt 2, und füllen Sie den Prozess wie unten beschrieben aus.
- Kontext: Dies ist ein Kubernetes-Manifest, um einen Ingress für den Luftstrom zu implementieren.
- Name: airflow-namespace
- Typ: Kubernetes-Manifest
- Artefaktquelle: Inline
- Fügen Sie den folgenden Inhalt in das Feld Wert ein:
```
apiVersion: v1
kind: Namespace
metadata:
  name: airflow
```
Wiederholen Sie Schritt 2, und füllen Sie den Prozess wie unten beschrieben aus.
- Kontext: Dies ist der Speicherort der Helm-Diagrammregistrierung.
- Name: helm-airflow
- Typ: Helm-Chart
- Helm-Diagramm-URL: oci://gru.ocir.io/yournamespace/airflow-helm/airflow
- Version: 8.6.1
Hinweis: Denken Sie daran, den Tournamespace aus Ihrer OCI-Registry zu ersetzen. Diese Registry wurde in früheren Phasen dieses Tutorials erstellt.
Wiederholen Sie Schritt 2, und füllen Sie den Prozess wie unten beschrieben aus.
- Kontext: Dies sind die Helm-Werte für die Airflow-Bereitstellung.
- Name: values-airflow-helm
- Typ: Allgemeines Artefakt
- Artefaktquelle: Inline
- Fügen Sie den Inhalt unten in das Feld Wert ein. Dadurch wird das Deployment im neuen Knotenpool erzwungen.
```
nodeSelector:
name: extra_workload
```

Zu diesem Zeitpunkt sollten Sie die folgenden Artefakte verwenden.

T1_1

Aufgabe 2: Build-Pipeline DevOps für Airflow erstellen

Wir haben keinen Code im Repository, nur die Datei build_spec.yaml. Der Grund dafür ist, dass Sie das offizielle Helm-Diagramm für Apache Airflow verwenden.

Gehen Sie zu Ihrem OCI DevOps-Projekt, klicken Sie auf Code-Repositorys, und erstellen Sie ein Repository mit dem Namen airflow-helm.
Klicken Sie auf Klonen, und notieren Sie sich das Repository ssh url.

Gehen Sie zu Ihrem Bastionhost-Shell-Terminal, laden Sie die Datei build_spec.yaml herunter, und übertragen Sie sie in Ihr eigenes Code-Repository auf OCI.

cd $HOME
git clone <your ssh code repository>
wget https://docs.us.oracle.com/en/learn/resource-manager-airflow-oke-part5/files/build_spec.yaml
git add .
git commit -m "new build spec added"
git push

T2_3

Aufgabe 3: Build-Pipeline für airflow-helm erstellen

Gehen Sie zu Ihrem Projekt DevOps, klicken Sie auf Pipelines erstellen, und klicken Sie dann auf Build-Pipeline erstellen.
Klicken Sie auf Neue Phase hinzufügen, und wählen Sie den Typ Verwalteter Build aus.
Wählen Sie das Primär-Code-Repository aus, und wählen Sie airflow-helm aus.
Sammeln Sie Vault-Secrets, die für dieses Luftstrom-Piepline benötigt werden.
1. Klicken Sie in der Oracle-Cloud-Konsole auf Identität und Sicherheit, klicken Sie auf Vault, und wählen Sie Ihren Vault aus.
2. Rufen Sie die OCID für die Secrets OCIRUser und OCIRToken ab, die Sie in den vorherigen Schritten dieses Tutorials erstellt haben.

Gehen Sie zu Ihrem Projekt DevOps, klicken Sie auf Pipelines erstellen, wählen Sie die Build-Pipeline für airflow-helm aus, klicken Sie auf die Registerkarte Parameter, und fügen Sie die folgenden Parameter hinzu:

Parametername	Wert
VAULT_HELM_REPO_USER	Vault-Secret-OCID für den Registry-Benutzer OCIRUser abrufen
VAULT_USER_AUTH_TOKEN	Vault-Secret-OCID für Ihr Registry-Token abrufen OCIRToken
COMPARTMENT_ID	Compartment-OCID abrufen
HELM_REPO	gru.ocir.io
HELM_REPO_URL	oci://gru.ocir.io/your_namespace/airflow-helm
APP_HOST	airflow.superocilab.com

Hinweis: Stellen Sie sicher, dass Ihre Region korrekt in der REPO-URL festgelegt ist. In diesem Tutorial lautet es "gru.ocir.io".

T3_5

Klicken Sie auf die Registerkarte Pipeline erstellen und dann auf Manuelle Ausführung starten, um die Build-Pipeline manuell auszuführen.

Aufgabe 4: Deployment-Pipeline für airflow-helm erstellen

Gehen Sie zum Projekt DevOps, klicken Sie auf Deployment-Pipelines, und erstellen Sie eine neue Pipeline namens airflow-helm-deploy.
Erstellen Sie eine neue Phase, um einen neuen Namespace in OKE zu erstellen, und wählen Sie Manifest auf Ihr Kubernetes-Cluster anwenden aus.
Erstellen Sie eine neue Phase, um den Luftstrom in OKE zu installieren, und wählen Sie Manifest auf Ihr Kubernetes-Cluster anwenden aus.
Erstellen Sie eine neue Phase, um Ingress für den Luftstrom in OKE zu erstellen, und wählen Sie Manifest auf Ihr Kubernetes-Cluster anwenden aus. Da wir einen Ingress-Controller einrichten, um von außerhalb von OKE auf unsere Microservices zuzugreifen, müssen wir auch für den Luftstrom einrichten.
Aktualisieren Sie die Build-Pipeline für den Luftstrom, und fügen Sie dem Deployment einen Trigger hinzu. Um das Deployment nach Abschluss der Build-Pipeline automatisch zu starten, müssen Sie einen Trigger für die airflow-helm-Build-Pipeline hinzufügen.

Die Build-Pipeline sollte jetzt wie folgt aussehen.

T4_5

Aufgabe 5: Go-Microservice-Parameter konfigurieren

Jetzt müssen wir den go-microservice konfigurieren, um die zuletzt erstellte Build-Pipeline für Airflow auslösen zu können.

Gehen Sie zu Ihrem Projekt DevOps, klicken Sie auf Pipelines erstellen, und notieren Sie sich die OCID für die airflow-helm-Build-Pipeline.
Klicken Sie in der Oracle Cloud-Konsole auf Entwicklerservices, klicken Sie unter "Ressourcenmanager" auf Stacks, wählen Sie den Stack Weitere CLI-Knoten aus, und notieren Sie sich die OCID.
Richten Sie Variablen im go-microservice-Code ein.

Hinweis: Die Go-Microservices sind ein Code, der mit den OCI-Ressourcen interagieren wird. Da wir gerade die Build-Pipeline für den Luftstrom erstellt haben, müssen wir Go-Microservices auf die Build-Pipeline aufmerksam machen, die er aufrufen muss. Dazu werden einige Änderungen an den Konfigurationszuordnungswerten vorgenommen, die in den Container in OKE eingefügt werden.
- Rufen Sie Ihre SSH-URL für Ihr OCI-Code-Repository von go-microservice ab.
- Öffnen Sie Ihre Bastion-Shellkonsole, und bearbeiten Sie die Datei configmap/values.yaml im Code-Repository von go-microservice.
```
cd $HOME
rm -rf go-microservice
git clone your_repo_ssh_url
cd go-microservice
vi chart-go-microservice/configmap/values.yaml   
```
- Fügen Sie die folgenden neuen Variablen am Ende der Datei configmap/values.yaml hinzu.
```
ENV_RM_STACK_ID: "<paste your stack ocid>"
ENV_DEVOPS_BUILD_ID: "<paste your build pipeline ocid"
```
- Prüfen Sie die letzten 3 Zeilen der Datei, und stellen Sie sicher, dass die letzten beiden Variablen hinzugefügt wurden.
```
tail -3 chart-go-microservice/configmap/values.yaml
```
- Jetzt müssen die Änderungen an das Code-Repository übertragen werden:
```
 git add .
 git commit -m "added new variables"
 git push
```
Gehen Sie zu Ihrem Projekt DevOps, wählen Sie Pipelines erstellen aus, und klicken Sie auf Go-microservice-pipeline.
1. Klicken Sie auf Manuelle Ausführung starten, um die Build-Pipeline für go-microservice erneut auszuführen und sicherzustellen, dass die Änderungen auf der configmap wirksam werden und im ausgeführten Container injiziert werden.
2. Prüfen Sie dann die Deployment-Pipeline, die von dieser Build-Pipeline ausgelöst wurde.

Ihr Go-Microservice ist jetzt bereit zur Arbeit!

Nächster Schritt

Um mit dem nächsten Tutorial in diesem Lernpfad fortzufahren, klicken Sie hier.

Danksagungen

Autor - Joao Tarla (Oracle LAD A-Team Solution Engineer)

Weitere Lernressourcen

Sehen Sie sich andere Übungen zu docs.oracle.com/learn an, oder greifen Sie auf weitere kostenlose Lerninhalte im Oracle Learning YouTube-Kanal zu. Besuchen Sie außerdem die Website education.oracle.com/learning-explorer, um Oracle Learning Explorer zu werden.

Produktdokumentation finden Sie im Oracle Help Center.

Titel und Copyright-Informationen

Create OCI DevOps pipelines for Apache Airflow and deploy it using Helm

F79811-01

April 2023