Avvio rapido: Usare GitHub Actions per connettersi ad Azure PostgreSQL

Articolo
12/05/2022
6 minuti per la lettura

SI APPLICA A: Database di Azure per PostgreSQL - Server singolo

SI APPLICA A: Database di Azure per PostgreSQL - Server singolo Database di Azure per PostgreSQL - Server flessibile

Usare un flusso di lavoro GitHub Actions per distribuire aggiornamenti di database a Database di Azure per PostgreSQL.

Prerequisiti

Prerequisiti:

Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
Un repository GitHub con i dati di esempio (data.sql). Se non si ha un account GitHub, è possibile iscriversi gratuitamente.
Un server di Database di Azure per PostgreSQL.
- Guida introduttiva: Creare un database di Azure per il server PostgreSQL nel portale di Azure

Panoramica dei file del flusso di lavoro

Un flusso di lavoro GitHub Actions viene definito da un file YAML (con estensione yml) nel percorso /.github/workflows/ del repository. Questa definizione contiene i vari passaggi e i parametri che costituiscono il flusso di lavoro.

Il file è costituito da due sezioni:

Sezione	Attività
autenticazione	1. Generare le credenziali di distribuzione.
Distribuzione	1. Distribuire il database.

Generare le credenziali per la distribuzione

Entità servizio
OpenID Connect

Creare un'entità servizio con il comando az ad sp create-for-rbac nell'interfaccia della riga di comando di Azure. Eseguire questo comando con Azure Cloud Shell nel portale di Azure oppure selezionando il pulsante Prova.

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

Nell'esempio precedente sostituire i segnaposto con l'ID sottoscrizione, il nome del gruppo di risorse e il nome dell'app. L'output è un oggetto JSON con le credenziali di assegnazione di ruolo che forniscono l'accesso all'app del servizio app simile a questo esempio. Copiare l'oggetto JSON per un uso successivo.

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

OpenID Connect è un metodo di autenticazione che usa token di breve durata. La configurazione di OpenID Connect con GitHub Actions è un processo più complesso che offre sicurezza avanzata.

Se non si dispone di un'applicazione esistente, registrare una nuova applicazione Active Directory e un'entità servizio che può accedere alle risorse. Creare l'applicazione Active Directory.
```
az ad app create --display-name myApp
```
Questo comando restituisce JSON con un appId oggetto che corrisponde client-ida . Salvare il valore da usare come AZURE_CLIENT_ID segreto GitHub in un secondo momento.

Si userà il valore durante la objectId creazione di credenziali federate con API Graph e fare riferimento a esso come APPLICATION-OBJECT-ID.
Creare un'entità servizio. Sostituire con l'appId $appID dall'output JSON.

Questo comando genera un output JSON diverso objectId e verrà usato nel passaggio successivo. Il nuovo objectId è .assignee-object-id

Copiare l'oggetto appOwnerTenantId da usare come segreto GitHub per AZURE_TENANT_ID un secondo momento.
```
 az ad sp create --id $appId
```
Creare una nuova assegnazione di ruolo in base alla sottoscrizione e all'oggetto. Per impostazione predefinita, l'assegnazione di ruolo verrà associata alla sottoscrizione predefinita. Sostituire $subscriptionId con l'ID sottoscrizione, $resourceGroupName con il nome del gruppo di risorse e $assigneeObjectId con l'oggetto generato assignee-object-id. Informazioni su come gestire le sottoscrizioni di Azure con l'interfaccia della riga di comando di Azure.
```
az role assignment create --role contributor --scope /subscriptions/$subscriptionId/resourceGroups/$resourceGroupName --subscription $subscriptionId --assignee-object-id  $assigneeObjectId --assignee-principal-type ServicePrincipal
```
Eseguire il comando seguente per creare una nuova credenziale di identità federata per l'applicazione active directory.
- Sostituire APPLICATION-OBJECT-ID con objectId (generato durante la creazione dell'app) per l'applicazione Active Directory.
- Impostare un valore per CREDENTIAL-NAME per fare riferimento in un secondo momento.
- Impostare subject. Il valore di questo valore è definito da GitHub a seconda del flusso di lavoro:
  - Processi nell'ambiente di GitHub Actions:repo:< Organization/Repository >:environment:< Name >
  - Per i processi non associati a un ambiente, includere il percorso di riferimento per branch/tag in base al percorso di riferimento usato per attivare il flusso di lavoro: repo:< Organization/Repository >:ref:< ref path>. Ad esempio, repo:n-username/ node_express:ref:refs/heads/my-branch o repo:n-username/ node_express:ref:refs/tags/my-tag.
  - Per i flussi di lavoro attivati da un evento di richiesta pull: repo:< Organization/Repository >:pull_request.
```
az rest --method POST --uri 'https://graph.microsoft.com/beta/applications/<APPLICATION-OBJECT-ID>/federatedIdentityCredentials' --body '{"name":"<CREDENTIAL-NAME>","issuer":"https://token.actions.githubusercontent.com","subject":"repo:organization/repository:ref:refs/heads/main","description":"Testing","audiences":["api://AzureADTokenExchange"]}' 
```

Per informazioni su come creare un'applicazione active directory, un'entità servizio e le credenziali federate in portale di Azure, vedere Connettere GitHub e Azure.

Copiare la stringa di connessione PostgreSQL

Nel portale di Azure passare a Database di Azure per PostgreSQL e aprire Impostazioni>Stringhe di connessione. Copiare la stringa di connessione per ADO.NET. Sostituire i valori segnaposto your_database e your_password. La stringa di connessione avrà un aspetto simile a questo.

Importante

Per Il server singolo usa user=adminusername@servername . Si noti che @servername è obbligatorio.
Per il server flessibile, usare user= adminusername senza .@servername

psql host={servername.postgres.database.azure.com} port=5432 dbname={your_database} user={adminusername} password={your_database_password} sslmode=require

La stringa di connessione verrà usata come segreto GitHub.

In GitHub passare al repository.
Selezionare Segreti di sicurezza > e azioni variabili>.
Selezionare New repository secret (Nuovo segreto del repository).
Incollare l'intero output JSON del comando dell'interfaccia della riga di comando di Azure nel campo del valore del segreto. Assegnare al segreto il nome AZURE_CREDENTIALS.
Selezionare Aggiungi segreto.

È necessario specificare l'ID client dell'applicazione, l'ID tenant e l'ID sottoscrizione all'azione di accesso. Questi valori possono essere forniti direttamente nel flusso di lavoro o possono essere archiviati nei segreti di GitHub e a cui si fa riferimento nel flusso di lavoro. Salvare i valori come segreti GitHub è l'opzione più sicura.

In GitHub passare al repository.
Selezionare Segreti di sicurezza > e azioni variabili>.
Selezionare New repository secret (Nuovo segreto del repository).
Creare segreti per AZURE_CLIENT_ID, AZURE_TENANT_IDe AZURE_SUBSCRIPTION_ID. Usare questi valori dall'applicazione Active Directory per i segreti di GitHub:

Segreto gitHub Applicazione Active Directory

AZURE_CLIENT_ID ID applicazione (client)

AZURE_TENANT_ID ID directory (tenant)

AZURE_SUBSCRIPTION_ID ID sottoscrizione
Salvare ogni segreto selezionando Aggiungi segreto.

Segreto gitHub	Applicazione Active Directory
AZURE_CLIENT_ID	ID applicazione (client)
AZURE_TENANT_ID	ID directory (tenant)
AZURE_SUBSCRIPTION_ID	ID sottoscrizione

Aggiungere il flusso di lavoro

Passare ad Actions per il repository GitHub.
Selezionare Set up your workflow yourself (Configurare manualmente il flusso di lavoro).
Eliminare tutti quello che segue la sezione on: del file del flusso di lavoro. Il flusso di lavoro rimanente, ad esempio, potrà essere simile al seguente.
```
name: CI

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

Rinominare il flusso di lavoro PostgreSQL for GitHub Actions e aggiungere le azioni checkout e login. Queste azioni eseguiranno il checkout del codice del sito e l'autenticazione con Azure usando i segreti GitHub creati in precedenza.

Entità servizio
OpenID Connect

name: PostgreSQL for GitHub Actions

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

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

name: PostgreSQL for GitHub Actions

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

jobs:
build:
    runs-on: ubuntu-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 }}

Usare l'azione di distribuzione di Azure PostgreSQL per connettersi all'istanza di PostgreSQL. Sostituire POSTGRESQL_SERVER_NAME con il nome del server. È necessario avere un file di dati PostgreSQL denominato data.sql al livello radice del repository.
```
 - uses: azure/postgresql@v1
   with:
    connection-string: ${{ secrets.AZURE_POSTGRESQL_CONNECTION_STRING }}
    server-name: POSTGRESQL_SERVER_NAME
    sql-file: './data.sql'
```

Completare il flusso di lavoro aggiungendo un'azione di disconnessione da Azure. Ecco il flusso di lavoro completato. Il file verrà visualizzato nella cartella .github/workflows del repository.

Entità servizio
OpenID Connect

name: PostgreSQL for GitHub Actions

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


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

- uses: azure/postgresql@v1
  with:
    server-name: POSTGRESQL_SERVER_NAME
    connection-string: ${{ secrets.AZURE_POSTGRESQL_CONNECTION_STRING }}
    sql-file: './data.sql'

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

name: PostgreSQL for GitHub Actions

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


jobs:
build:
    runs-on: ubuntu-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 }}

- uses: azure/postgresql@v1
  with:
    server-name: POSTGRESQL_SERVER_NAME
    connection-string: ${{ secrets.AZURE_POSTGRESQL_CONNECTION_STRING }}
    sql-file: './data.sql'

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

Esaminare la distribuzione

Passare ad Actions per il repository GitHub.
Aprire il primo risultato per visualizzare i log dettagliati dell'esecuzione del flusso di lavoro.

Pulire le risorse

Quando il database PostgreSQL di Azure e il repository non sono più necessari, pulire le risorse distribuite eliminando il gruppo di risorse e il repository GitHub.

Passaggi successivi

Informazioni sull'integrazione di Azure e GitHub

Informazioni su come connettersi al server