Automatisieren von Projektaktionen in Ihrem Git Repository

In diesem Tutorial erfahren Sie, wie Sie eine Pipeline einrichten, um eine Aktualisierung in Ihrem Projekt auszulösen, wenn Konfigurationsänderungen in den Hauptzweig in Ihrem Repository zusammengeführt werden. In diesem Tutorial erfahren Sie, wie Sie mithilfe der Pipelines und Toolchains Ihrer Wahl allgemeine Aufgaben in einem Projekt automatisieren, z. B. die Validierung einer .

Dies ist eine experimentelle Funktion, die zu Evaluierungs- und Testzwecken verfügbar ist und ohne Vorankündigung geändert werden kann.

In diesem Tutorial geht es um den einfachen Anwendungsfall der Aktualisierung einer Konfiguration in einem Projekt, wenn Änderungen in den Hauptzweig Ihres Repositorys integriert werden, wie in der folgenden Abbildung dargestellt:

Das Bild zeigt ein Update, das vom Projekt zu einem Nebenzweig im Repository geht. Dann zeigt ein Pfeil an, dass der Seitenzweig in den Hauptzweig zusammengeführt wird, wodurch die CD-Pipeline ausgelöst wird. Die CD-Pipeline enthält einen Trigger zum Aktualisieren der Konfigurationen in Ihrem Projekt basierend auf den Aktualisierungen in Ihrem Hauptzweig. — Automatische Aktualisierung Ihres Projekts, nachdem Änderungen in Ihren Hauptzweig integriert wurden.

Da Pipelines und Toolchains anpassbar sind, können Ihnen die Prinzipien in diesem Tutorial dabei helfen, andere gängige Aktionen innerhalb eines Projekts zu automatisieren, z. B. das Validieren und Bereitstellen von Konfigurationsänderungen, nachdem diese mit dem Hauptzweig in Ihrem Repository zusammengeführt wurden. Dieses Tutorial verwendet GitHub Aktionen und -Workflows, um eine Pipeline zwischen dem Repository und dem Projekt zu automatisieren. Passen Sie im Laufe des Lernprogramms jeden Schritt so an, dass er zu den CI- und CD-Pipelines und -Prozessen Ihres Repositorys passt.

Sie können Entwurfskonfigurationen erst validieren und bereitstellen, nachdem sie mit dem Zweig in Ihrem Repository zusammengeführt wurden, der Ihre CD-Pipelines verwaltet. Sie müssen auch die Aktualisierungen aus Ihrem Repository mit Ihrem Projekt synchronisieren, indem Sie Konfigurationen aktualisieren, bevor Sie diese Konfigurationen validieren und bereitstellen können. Sie können dieses Update automatisieren, indem Sie die API-Methode project.config.update (wie in diesem Tutorial beschrieben) oder den CLI-Befehl ibmcloud project config-update verwenden.

Vorbereitende Schritte

Vergewissern Sie sich, dass Sie im Dienst IBM Cloud Projects die Rolle Editor haben.
Führen Sie die Schritte aus, um Ihr Projekt mit einem Git Repository zu verbinden. Verbinden Sie für die Zwecke dieses Tutorials ein leeres Projekt mit einem GitHub-Repository.

Hinzufügen von Geheimnissen und Variablen zu GitHub

Erstellen Sie Geheimnisse und Variablen im GitHub Repository, das Sie mit Ihrem Projekt verbunden haben. Diese Geheimnisse und Variablen werden im GitHub Workflow verwendet. Fügen Sie die folgenden Geheimnisse und Variablen hinzu:

Zur Authentifizierung bei Ihrem Projekt müssen Sie einen IBM Cloud-API-Schlüssel in Ihren GitHub Workflow aufnehmen. Um den API-Schlüssel sicher aufzubewahren, führen Sie die Schritte zum Erstellen eines Geheimnisses für ein Repository aus, um den API-Schlüssel als Geheimnis in GitHub zu speichern. Nennen Sie das Geheimnis für die Zwecke dieses Tutorials IBM_CLOUD_API_KEY.

Führen Sie als Nächstes die Schritte zum Erstellen von Konfigurationsvariablen für Ihr GitHub Repository aus. Speichern Sie die folgenden Variablen:

Liste der Variablen, die in Ihrem GitHub-Repository gespeichert werden sollen
Variablenname	Wert	Beschreibung
`CONFIG_FOLDER_PATH`	`configs`	Der Pfad zum Repository-Ordner, der mit Ihrem Projekt verbunden ist. Dieser Ordner enthält die Konfigurationsdateien Ihres Projekts.
`IAM_URL`	`https://iam.cloud.ibm.com`	Die URL auf Cloud Identity and Access Management.
`PROJECTS_API_BASE_URL`	`https://projects.api.cloud.ibm.com`	Die URL zur Projekt-API.

Erstellen eines Workflows in GitHub

Führen Sie die Schritte zum Schreiben eines Workflows im GitHub-Repository aus, das Sie mit Ihrem Projekt verbunden haben.

Beginnen Sie mit einer Beispiel-Workflow-Datei, die Sie nach Bedarf in GitHub ändern können.

Sie können den Workflow mit beliebig vielen Jobs anpassen, die Sie benötigen. Der folgende Code muss jedoch eingefügt werden, um Konfigurationen in Ihrem Projekt erfolgreich zu aktualisieren, wenn Änderungen von einem Nebenzweig in den Hauptzweig Ihres Repositorys zusammengeführt werden:

Fügen Sie dem Abschnitt „ on des Workflows types: [closed] hinzu, um den Workflow auszulösen, wenn eine Pull-Anforderung an den Hauptzweig geschlossen wird:

   # Controls when the workflow will run
   on:
     # Triggers the workflow on push or pull request events but only for the "main" branch
     # push:
     #   branches: [ "main" ]
     pull_request:
       branches: [ "main" ]
       types: [closed]

Fügen Sie eine if-Anweisung hinzu, die diesen Workflow auslöst, wenn Änderungen in den Hauptzweig zusammengeführt werden:
```
jobs:
  update-config:
    if: github.event.pull_request.merged == true
    runs-on: ubuntu-latest
```

Fügen Sie den folgenden Code in den Workflow ein, damit Ihr Repository eine Verbindung zu Ihrem Projekt herstellen kann, wobei IBM_CLOUD_API_KEY der Name des Geheimnisses ist, das Sie zu GitHub:

  IAM_TOKEN=$(curl -X POST "https://iam.test.cloud.ibm.com/identity/token" \
        -H "Content-Type: application/x-www-form-urlencoded" \
         -H "Accept: application/json" \
         -d "grant_type=urn:ibm:params:oauth:grant-type:apikey&apikey=${{ secrets.IBM_CLOUD_API_KEY }}" | jq -r .access_token)

Fügen Sie den folgenden Code ein, um zu identifizieren, welche Konfigurationen bearbeitet wurden:

          # get files changed in the PR
          changed_files=$(git diff --name-only HEAD^ HEAD)
          echo "Changed files: $changed_files"

          for file in $changed_files; do
            # find config files that were changed
            if [[ "${file}" == ${{ vars.CONFIG_FOLDER_PATH }}/* ]] && [ -s "${file}" ]; then
              echo "Config file updated: ${file}"

              # extract data from config files
              PROJECT_ID=$(jq -r '.project_id' $file)
              CONFIG_ID=$(jq -r '.config_id' $file)
              DEF=$(jq '.definition' $file)

              echo "Project ID: ${PROJECT_ID}"
              echo "Config ID: ${CONFIG_ID}"

Fügen Sie den folgenden Code ein, um die bearbeiteten Konfigurationen in Ihrem Projekt zu aktualisieren:

              # update config definition
              RESPONSE=$(curl -X PATCH "${BASE_URL}/v1/projects/${PROJECT_ID}/configs/${CONFIG_ID}" \
              --header "Authorization: Bearer ${IAM_TOKEN}" \
              --header "Accept: application/json" \
              --header "Content-Type: application/json" \
              --data "{ \"definition\": ${DEF} }")

Beispiel einer Workflow-Datei

Der folgende Codeausschnitt kann als Vorlage für Ihre Workflow-Datei verwendet werden:

name: Projects Git Integration Workflow

# Controls when the workflow will run
on:
  # Triggers the workflow on push or pull request events but only for the "main" branch
  pull_request:
    branches: [ "main" ]
    types: [closed]

  # Allows you to run this workflow manually from the Actions tab
  workflow_dispatch:

jobs:
  update-configs:
    if: github.event.pull_request.merged == true
    runs-on: ubuntu-latest
    steps:
      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Update Project Configs
        run: |
          IAM_TOKEN=$(curl -X POST "${{ vars.IAM_URL }}/identity/token" \
          -H "Content-Type: application/x-www-form-urlencoded" \
          -H "Accept: application/json" \
          -d "grant_type=urn:ibm:params:oauth:grant-type:apikey&apikey=${{ secrets.IBM_CLOUD_API_KEY }}" | jq -r .access_token)

          BASE_URL=${{ vars.PROJECTS_API_BASE_URL }}

          # get files changed in the PR
          changed_files=$(git diff --name-only HEAD^ HEAD)
          echo "Changed files: $changed_files"

          for file in $changed_files; do
            # find config files that were changed
            if [[ "${file}" == ${{ vars.CONFIG_FOLDER_PATH }}/* ]] && [ -s "${file}" ]; then
              echo "Config file updated: ${file}"

              # extract data from config files
              PROJECT_ID=$(jq -r '.project_id' $file)
              CONFIG_ID=$(jq -r '.config_id' $file)
              DEF=$(jq '.definition' $file)

              echo "Project ID: ${PROJECT_ID}"
              echo "Config ID: ${CONFIG_ID}"

              # update config definition
              RESPONSE=$(curl -X PATCH "${BASE_URL}/v1/projects/${PROJECT_ID}/configs/${CONFIG_ID}" \
              --header "Authorization: Bearer ${IAM_TOKEN}" \
              --header "Accept: application/json" \
              --header "Content-Type: application/json" \
              --data "{ \"definition\": ${DEF} }")

              echo $RESPONSE
              ERR_CODE=$(echo $RESPONSE | jq '.code')
              if [ "${ERR_CODE}" != "null" ]; then
                exit 1
              fi
            else
              echo "Not a project configuration file: ${file}"
            fi
          done

Testen des Workflows

Nachdem Ihr Workflow nun in GitHub, stellen Sie sicher, dass der Workflow erfolgreich ausgeführt wird, indem Sie dem Projekt eine Konfiguration hinzufügen. Führen Sie die folgenden Schritte aus:

Klicken Sie in der IBM Cloud-Konsole auf das Navigationsmenüsymbol > Projekte und wählen Sie das Projekt aus, das mit Ihrem GitHub Repository verbunden ist.
Klicken Sie auf „Erstellen“, um Ihrem Projekt eine Konfiguration hinzuzufügen. Stellen Sie sicher, dass Sie einen Nebenzweig auswählen, in dem Ihre Konfiguration gespeichert wird.
Bearbeiten Sie die Konfiguration. Fügen Sie beispielsweise im Konfigurationsbereich eine Authentifizierungsmethode hinzu.
Wählen Sie den Nebenzweig aus, in dem Sie Ihre Änderungen festschreiben möchten.
Klicken Sie auf Commit.
Gehen Sie zu Ihrem GitHub-Repository und öffnen Sie eine Pull-Anfrage, um den Nebenzweig mit dem Hauptzweig Ihres Repositorys zu integrieren.
Überprüfen Sie, ob Ihr Workflow ausgeführt wird, wenn der Nebenzweig in den Hauptzweig integriert wird. Sie können dies im GitHub-Repository und im Projekt überprüfen:
1. Gehen Sie im GitHub Repository zur Registerkarte „Aktionen“ und wählen Sie den Workflow aus. Überprüfen Sie, ob die Aktualisierung erfolgreich durchgeführt wurde.
2. Klicken Sie in Ihrem Projekt auf das Symbol „Optionen “, dann auf das > „Bearbeiten“ für die hinzugefügte Konfiguration und wechseln Sie zum Hauptzweig. Überprüfen Sie, ob Ihr Update angewendet wurde. Beispielsweise ist die Authentifizierungsmethode, die Sie zuvor hinzugefügt haben, im Konfigurationsbereich enthalten.