Herstellen einer Verbindung mit Azure SQL-Datenbank mithilfe von GitHub Actions

Artikel
02/14/2024

Verwenden Sie als Einstieg in GitHub Actions einen Workflow zum Bereitstellen von Datenbankupdates für Azure SQL-Datenbank.

Voraussetzungen

Erforderlich:

Ein Azure-Konto mit einem aktiven Abonnement. Sie können kostenlos ein Konto erstellen.
Ein GitHub-Repository mit einem DACPAC-Paket (Database.dacpac). Wenn Sie kein GitHub-Konto besitzen, können Sie sich kostenlos registrieren.
Azure SQL-Datenbank. Schnellstart: Erstellen einer Azure SQL-Einzeldatenbank.
Eine DACPAC-Datei , die in Ihre Datenbank importiert werden soll.

Übersicht über die Workflowdatei

Ein GitHub Actions-Workflow wird durch eine YAML-Datei (.yml) im Pfad /.github/workflows/ in Ihrem Repository definiert. Diese Definition enthält die verschiedenen Schritte und Parameter, die den Workflow bilden.

Die Datei besteht aus zwei Abschnitten:

`Section`	Aufgaben
Authentifizierung	1.1. Generieren von Anmeldeinformationen für die Bereitstellung.
Bereitstellen	1. Bereitstellen der Datenbank.

Generieren von Anmeldeinformationen für die Bereitstellung

Dienstprinzipal
OpenID Connect

Generieren Sie in der Azure CLI mit dem Befehl az ad sp create-for-rbac einen Dienstprinzipal. Führen Sie diesen Befehl mit Azure Cloud Shell im Azure-Portal oder durch Auswählen der Schaltfläche Ausprobieren aus.

az ad sp create-for-rbac --name "myML" --role contributor \
                            --scopes /subscriptions/<subscription-id>/resourceGroups/<group-name> \
                            --json-auth

Der Parameter --json-auth ist in Azure CLI-Versionen >= 2.51.0 verfügbar. Frühere Versionen nutzen --sdk-auth mit einer Einstellungswarnung.

Ersetzen Sie im obigen Beispiel die Platzhalter durch Ihre Abonnement-ID, den Ressourcengruppennamen und den App-Namen. Die Ausgabe ist ein JSON-Objekt mit den Anmeldeinformationen für die Rollenzuweisung, die ähnlich wie unten Zugriff auf Ihre App Service-App gewähren. Kopieren Sie dieses JSON-Objekt zur späteren Verwendung.

  {
    "clientId": "<GUID>",
    "clientSecret": "<GUID>",
    "subscriptionId": "<GUID>",
    "tenantId": "<GUID>",
    (...)
  }

OpenID Connect ist eine Authentifizierungsmethode, die kurzlebige Token verwendet. Das Einrichten von OpenID Connect mit GitHub Actions ist komplexer und bietet mehr Sicherheit.

Wenn Sie keine bestehende Anwendung besitzen, registrieren Sie eine neue Microsoft Entra-Anwendung und einen neuen Dienstprinzipal, die auf Ressourcen zugreifen können.
```
az ad app create --display-name myApp
```
Dieser Befehl gibt JSON mit einem appId aus, das Ihrem client-id entspricht. Dies objectId ist APPLICATION-OBJECT-ID und wird zum Erstellen von Verbundanmeldeinformationen mit Graph-API-Anrufen verwendet. Speichern Sie den Wert, der später als AZURE_CLIENT_IDGitHub-Geheimnis verwendet werden soll.
Erstellen eines Dienstprinzipals. Ersetzen Sie $appID durch die AppId aus Ihrer JSON-Ausgabe. Dieser Befehl generiert eine JSON-Ausgabe mit einem anderen objectId, was im nächsten Schritt verwendet wird. Der neue objectId ist der assignee-object-id.

Dieser Befehl generiert eine JSON-Ausgabe mit einem anderen objectId und wird im nächsten Schritt verwendet. Der neue objectId ist der assignee-object-id.

Kopieren Sie die appOwnerTenantId, um sie später als GitHub-Geheimnis für AZURE_TENANT_ID zu verwenden.
```
 az ad sp create --id $appId
```
Erstellen Sie eine neue Rollenzuweisung nach Abonnement und Objekt. Standardmäßig ist die Rollenzuweisung an Ihr Standardabonnement gebunden. Ersetzen Sie $subscriptionId durch Ihre Abonnement-ID, $resourceGroupName durch den Namen Ihrer Ressourcengruppe und $assigneeObjectId durch die generierte assignee-object-id (die neu erstellte Dienstprinzipalobjekt-ID).
```
az role assignment create --role contributor --subscription $subscriptionId --assignee-object-id  $assigneeObjectId --assignee-principal-type ServicePrincipal --scope /subscriptions/$subscriptionId/resourceGroups/$resourceGroupName
```
Führen Sie den folgenden Befehl aus, um neue Anmeldeinformationen für die Verbundidentität für Ihre Microsoft Entra-Anwendung zu erstellen.
- Ersetzen Sie APPLICATION-OBJECT-ID durch die ObjectId (die beim Erstellen der Anwendung generiert wurde) für Ihre Microsoft Entra-Anwendung.
- Legen Sie einen Wert für CREDENTIAL-NAME fest, um später auf ihn zu verweisen.
- Legen Sie die subject fest. Dieser Wert wird von GitHub in Abhängigkeit von Ihrem Workflow festgelegt:
  - Aufträge in Ihrer GitHub Actions-Umgebung: repo:< Organization/Repository >:environment:< Name >
  - Bei Aufträgen, die nicht an eine Umgebung gebunden sind, fügen Sie den Referenzpfad für den Branch/Tag auf der Grundlage des für die Auslösung des Workflows verwendeten Referenzpfads ein: repo:< Organization/Repository >:ref:< ref path>. Zum Beispiel: repo:n-username/ node_express:ref:refs/heads/my-branch oder repo:n-username/ node_express:ref:refs/tags/my-tag.
  - Für Workflows, die durch ein Pull Request-Ereignis ausgelöst werden: repo:< Organization/Repository >:pull_request.
```
az ad app federated-credential create --id <APPLICATION-OBJECT-ID> --parameters credential.json
("credential.json" contains the following content)
{
    "name": "<CREDENTIAL-NAME>",
    "issuer": "https://token.actions.githubusercontent.com",
    "subject": "repo:octo-org/octo-repo:environment:Production",
    "description": "Testing",
    "audiences": [
        "api://AzureADTokenExchange"
    ]
}
```

Kopieren der SQL-Verbindungszeichenfolge

Wechseln Sie im Azure-Portal zur Azure SQL-Datenbank, und öffnen Sie Einstellungen>Verbindungszeichenfolgen. Kopieren Sie die ADO.NET-Verbindungszeichenfolge. Ersetzen Sie die Platzhalterwerte für your_database und your_password.

Sie legen die Verbindungszeichenfolge als GitHub-Geheimnis fest, AZURE_SQL_CONNECTION_STRING.

Wechseln Sie in GitHub zu Ihrem Repository.
Gehen Sie im Navigationsmenü auf Einstellungen.
Wählen Sie Security > Secrets and variables > Actions (Sicherheit > Geheimnisse und Variablen > Aktionen) aus.
Wählen Sie New repository secret (Neues Repositorygeheimnis) aus.
Fügen Sie die gesamte JSON-Ausgabe aus dem Azure CLI-Befehl in das Wertfeld des Geheimnisses ein. Geben Sie dem Geheimnis den Namen AZURE_CREDENTIALS.
Klicken Sie auf Add secret (Geheimnis hinzufügen).

Sie müssen die Client-ID Ihrer Anwendung, die Mandanten-ID und die Abonnement-ID für die Anmeldeaktion bereitstellen. Diese Werte können entweder direkt im Workflow bereitgestellt werden oder in GitHub-Geheimnissen gespeichert und darauf in Ihrem Workflow verwiesen werden. Das Speichern der Werte als GitHub-Geheimnisse ist die sicherere Option.

Wechseln Sie in GitHub zu Ihrem Repository.
Wählen Sie Security > Secrets and variables > Actions (Sicherheit > Geheimnisse und Variablen > Aktionen) aus.
Wählen Sie New repository secret (Neues Repositorygeheimnis) aus.
Erstellen Sie Geheimnisse für AZURE_CLIENT_ID, AZURE_TENANT_ID und AZURE_SUBSCRIPTION_ID. Verwenden Sie diese Werte aus Ihrer Microsoft Entra-Anwendung für Ihre GitHub-Geheimnisse:

GitHub-Geheimnis Microsoft Entra-Anwendung

AZURE_CLIENT_ID Anwendungs-ID (Client)

AZURE_TENANT_ID Verzeichnis-ID (Mandant)

AZURE_SUBSCRIPTION_ID Abonnement-ID
Speichern Sie jedes Geheimnis, indem Sie Geheimnis hinzufügen auswählen.

GitHub-Geheimnis	Microsoft Entra-Anwendung
AZURE_CLIENT_ID	Anwendungs-ID (Client)
AZURE_TENANT_ID	Verzeichnis-ID (Mandant)
AZURE_SUBSCRIPTION_ID	Abonnement-ID

Hinzufügen der geheimen SQL-Verbindungszeichenfolge

Wechseln Sie in GitHub zu Ihrem Repository.
Gehen Sie im Navigationsmenü auf Einstellungen.
Wählen Sie Security > Secrets and variables > Actions (Sicherheit > Geheimnisse und Variablen > Aktionen) aus.
Wählen Sie New repository secret (Neues Repositorygeheimnis) aus.
Fügen Sie Ihre SQL-Verbindungszeichenfolge ein. Geben Sie dem Geheimnis den Namen AZURE_SQL_CONNECTION_STRING.
Klicken Sie auf Add secret (Geheimnis hinzufügen).

Hinzufügen des Workflows

Navigieren Sie für Ihr GitHub-Repository zu Actions (Aktionen).
Wählen Sie Set up your workflow yourself (Workflow selbst einrichten) aus.
Löschen Sie alles nach dem Abschnitt on: Ihrer Workflowdatei. Der verbleibende Workflow könnte beispielsweise wie folgt aussehen.
```
name: SQL for GitHub Actions

on:
    push:
        branches: [ main ]
    pull_request:
        branches: [ main ]
```

Benennen Sie den Workflow in SQL for GitHub Actions um, und fügen Sie die Aktionen zum Auschecken und Anmelden hinzu. Diese Aktionen checken Ihren Websitecode aus und authentifizieren mit Azure mithilfe des zuvor von Ihnen erstellten GitHub-Geheimnisses AZURE_CREDENTIALS.

Dienstprinzipal
OpenID Connect

name: SQL for GitHub Actions

on:
    push:
        branches: [ main ]
    pull_request:
        branches: [ main ]

jobs:
    build:
        runs-on: windows-latest
        steps:
         - uses: actions/checkout@v1
         - uses: azure/login@v1
           with:
            creds: ${{ secrets.AZURE_CREDENTIALS }}

    name: SQL for GitHub Actions

    on:
        push:
            branches: [ main ]
        pull_request:
            branches: [ main ]

    jobs:
        build:
            runs-on: windows-latest
            steps:
             - uses: actions/checkout@v1
             - uses: azure/login@v1
               with:
                client-id: ${{ secrets.AZURE_CLIENT_ID }}
                tenant-id: ${{ secrets.AZURE_TENANT_ID }}
                subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

Verwenden Sie die Aktion für die Azure SQL-Bereitstellung, um eine Verbindung mit Ihrer SQL-Instanz herzustellen. Sie sollten über ein DACPAC-Paket (Database.dacpac) auf der Stammebene Ihres Repositorys verfügen. Verwenden Sie den AZURE_SQL_CONNECTION_STRING zuvor erstellten GitHub-Geheimschlüssel.
```
- uses: azure/sql-action@v2
  with:
    connection-string: ${{ secrets.AZURE_SQL_CONNECTION_STRING }}
    path: './Database.dacpac'
    action: 'Publish'
```

Vervollständigen Sie Ihren Workflow, indem Sie eine Aktion zum Abmelden von Azure hinzufügen. Hier sehen Sie den vollständigen Workflow. Die Datei erscheint im Ordner .github/workflows Ihres Repositorys.

Dienstprinzipal
OpenID Connect

name: SQL for GitHub Actions

on:
    push:
        branches: [ main ]
    pull_request:
        branches: [ main ]

jobs:
    build:
        runs-on: windows-latest
        steps:
         - uses: actions/checkout@v1
         - uses: azure/login@v1
           with:
            creds: ${{ secrets.AZURE_CREDENTIALS }}
         - uses: azure/sql-action@v2
           with:
            connection-string: ${{ secrets.AZURE_SQL_CONNECTION_STRING }}
            path: './Database.dacpac'
            action: 'Publish'

            # Azure logout 
         - name: logout
           run: |
              az logout

    name: SQL for GitHub Actions

    on:
        push:
            branches: [ main ]
        pull_request:
            branches: [ main ]

    jobs:
        build:
            runs-on: windows-latest
            steps:
             - uses: actions/checkout@v1
             - uses: azure/login@v1
               with:
                client-id: ${{ secrets.AZURE_CLIENT_ID }}
                tenant-id: ${{ secrets.AZURE_TENANT_ID }}
                subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
            # Azure logout 
             - name: logout
               run: |
                 az logout

Überprüfen der Bereitstellung

Navigieren Sie für Ihr GitHub-Repository zu Actions (Aktionen).
Öffnen Sie das erste Ergebnis, um ausführliche Protokolle zur Ausführung des Workflows anzuzeigen.

Bereinigen von Ressourcen

Wenn Ihre Azure SQL-Datenbank und das Repository nicht mehr benötigt werden, bereinigen Sie die bereitgestellten Ressourcen, indem Sie die Ressourcengruppe und Ihr GitHub-Repository löschen.

Nächste Schritte

Weitere Informationen zu Azure und zur GitHub-Integration

Freigeben über