Share via

Esercitazione: Usare un servizio PostgreSQL per lo sviluppo

  • Articolo

App Contenitore di Azure consente di connettersi a servizi di sviluppo e di livello di produzione per offrire un'ampia gamma di funzionalità alle applicazioni.

In questa esercitazione si apprenderà come usare un servizio PostgreSQL di sviluppo con app contenitore.

I comandi dell'interfaccia della riga di comando di Azure e i frammenti di modello Bicep sono disponibili in questa esercitazione. Se si usa Bicep, è possibile aggiungere tutti i frammenti a un singolo file Bicep e distribuire il modello contemporaneamente.

  • Creare un ambiente app contenitore per distribuire le app del servizio e del contenitore
  • Creare un servizio PostgreSQL
  • Creare e usare un'app da riga di comando per usare il servizio PostgreSQL di sviluppo
  • Creare un'app pgweb
  • Scrivere dati nel database PostgreSQL

Prerequisiti

Nota

Per una distribuzione di un comando, passare all'ultimo azdpassaggio del modello.

Installazione

  1. Definire le variabili per i valori comuni.

    RESOURCE_GROUP="postgres-dev"
LOCATION="northcentralus"
ENVIRONMENT="aca-env"
PG_SVC="postgres01"
PSQL_CLI_APP="psql-cloud-cli-app"

  2. Accedere ad Azure.

    az login

  3. Aggiornare l'interfaccia della riga di comando alla versione più recente.

    az upgrade

  4. Aggiornare Bicep alla versione più recente.

    az bicep upgrade

  5. Aggiungere l'estensione containerapp .

    az extension add --name containerapp --upgrade

  6. Registrare gli spazi dei nomi necessari.

    az provider register --namespace Microsoft.App

    az provider register --namespace Microsoft.OperationalInsights

Creare un ambiente di app contenitore

  1. Crea un gruppo di risorse.

    az group create \
    --name "$RESOURCE_GROUP" \
    --location "$LOCATION"

  2. Creare un ambiente app contenitore.

    az containerapp env create \
  --name "$ENVIRONMENT" \
  --resource-group "$RESOURCE_GROUP" \
  --location "$LOCATION"

Creare un servizio PostgreSQL

  1. Creare un servizio PostgreSQL.

    az containerapp add-on postgres create \
    --name "$PG_SVC" \
    --resource-group "$RESOURCE_GROUP" \
    --environment "$ENVIRONMENT"

  2. Visualizzare l'output del log dall'istanza di Postgres

    Usare il logs comando per visualizzare i messaggi di log.

    az containerapp logs show \
    --name $PG_SVC \
    --resource-group $RESOURCE_GROUP \
    --follow --tail 30

    Screenshot dei log del servizio PostgreSQL dell'app contenitore.

Creare un'app per testare il servizio

Quando si crea l'app, si inizia creando un'app di debug per usare l'interfaccia della psql riga di comando per connettersi all'istanza di PostgreSQL.

  1. Creare un'app psql associata al servizio PostgreSQL.

    az containerapp create \
    --name "$PSQL_CLI_APP" \
    --image mcr.microsoft.com/k8se/services/postgres:14 \
    --bind "$PG_SVC" \
    --environment "$ENVIRONMENT" \
    --resource-group "$RESOURCE_GROUP" \
    --min-replicas 1 \
    --max-replicas 1 \
    --command "/bin/sleep" "infinity"

  2. Eseguire il comando dell'interfaccia della riga exec di comando per connettersi all'app di test.

    az containerapp exec \
    --name $PSQL_CLI_APP \
    --resource-group $RESOURCE_GROUP \
    --command /bin/bash

    Quando si usa --bind o serviceBinds nell'app di test, le informazioni di connessione vengono inserite nell'ambiente dell'applicazione. Dopo aver eseguito la connessione al contenitore di test, è possibile controllare i valori usando il env comando .

    env | grep "^POSTGRES_"

POSTGRES_HOST=postgres01
POSTGRES_PASSWORD=AiSf...
POSTGRES_SSL=disable
POSTGRES_URL=postgres://postgres:AiSf...@postgres01:5432/postgres?sslmode=disable
POSTGRES_DATABASE=postgres
POSTGRES_PORT=5432
POSTGRES_USERNAME=postgres
POSTGRES_CONNECTION_STRING=host=postgres01 database=postgres user=postgres password=AiSf...

  3. Per psql connettersi al servizio

    psql $POSTGRES_URL

    Screenshot dell'app contenitore usando pgsql per connettersi a un servizio PostgreSQL.

  4. Creare una tabella denominata accounts e inserire dati.

    postgres=# CREATE TABLE accounts (
    user_id serial PRIMARY KEY,
    username VARCHAR ( 50 ) UNIQUE NOT NULL,
    email VARCHAR ( 255 ) UNIQUE NOT NULL,
    created_on TIMESTAMP NOT NULL,
    last_login TIMESTAMP 
);

postgres=# INSERT INTO accounts (username, email, created_on)
VALUES
('user1', 'user1@example.com', current_timestamp),
('user2', 'user2@example.com', current_timestamp),
('user3', 'user3@example.com', current_timestamp);

postgres=# SELECT * FROM accounts;

    Screenshot dell'app contenitore che usa pgsql connettersi a PostgreSQL e creare una tabella e inizializzare alcuni dati.

Uso di un servizio di sviluppo con un'app esistente

Se si dispone già di un'app che usa PostgreSQL, è possibile modificare il modo in cui vengono caricate le informazioni di connessione.

Creare prima di tutto le variabili di ambiente seguenti.

POSTGRES_HOST=postgres01
POSTGRES_PASSWORD=AiSf...
POSTGRES_SSL=disable
POSTGRES_URL=postgres://postgres:AiSf...@postgres01:5432/postgres?sslmode=disable
POSTGRES_DATABASE=postgres
POSTGRES_PORT=5432
POSTGRES_USERNAME=postgres
POSTGRES_CONNECTION_STRING=host=postgres01 database=postgres user=postgres password=AiSf...

Usando l'interfaccia della riga di comando (o Bicep) è possibile aggiornare l'app da aggiungere --bind $PG_SVC per usare il servizio di sviluppo.

Associazione al servizio di sviluppo

Distribuire pgweb per visualizzare e gestire l'istanza di PostgreSQL.

Vedere Bicep o azd esempio.

Screenshot della connessione di pgweb Container App al servizio PostgreSQL.

Distribuire tutte le risorse

Usare gli esempi seguenti per distribuire tutte le risorse contemporaneamente.

Bicep

Il modello Bicep seguente contiene tutte le risorse di questa esercitazione.

È possibile creare un postgres-dev.bicep file con questo contenuto.

targetScope = 'resourceGroup'
param location string = resourceGroup().location
param appEnvironmentName string = 'aca-env'
param pgSvcName string = 'postgres01'
param pgsqlCliAppName string = 'psql-cloud-cli-app'

resource logAnalytics 'Microsoft.OperationalInsights/workspaces@2022-10-01' = {
  name: '${appEnvironmentName}-log-analytics'
  location: location
  properties: {
    sku: {
      name: 'PerGB2018'
    }
  }
}

resource appEnvironment 'Microsoft.App/managedEnvironments@2023-04-01-preview' = {
  name: appEnvironmentName
  location: location
  properties: {
    appLogsConfiguration: {
      destination: 'log-analytics'
      logAnalyticsConfiguration: {
        customerId: logAnalytics.properties.customerId
        sharedKey: logAnalytics.listKeys().primarySharedKey
      }
    }
  }
}

resource postgres 'Microsoft.App/containerApps@2023-04-01-preview' = {
name: pgSvcName
  location: location
  properties: {
    environmentId: appEnvironment.id
    configuration: {
      service: {
          type: 'postgres'
      }
    }
  }
}

resource pgsqlCli 'Microsoft.App/containerApps@2023-04-01-preview' = {
  name: pgsqlCliAppName
  location: location
  properties: {
    environmentId: appEnvironment.id
    template: {
      serviceBinds: [
        {
          serviceId: postgres.id
        }
      ]
      containers: [
        {
          name: 'psql'
          image: 'mcr.microsoft.com/k8se/services/postgres:14'
          command: [ '/bin/sleep', 'infinity' ]
        }
      ]
      scale: {
        minReplicas: 1
        maxReplicas: 1
      }
    }
  }
}

resource pgweb 'Microsoft.App/containerApps@2023-04-01-preview' = {
  name: 'pgweb'
  location: location
  properties: {
    environmentId: appEnvironment.id
    configuration: {
      ingress: {
        external: true
        targetPort: 8081
      }
    }
    template: {
      serviceBinds: [
        {
          serviceId: postgres.id
          name: 'postgres'
        }
      ]
      containers: [
        {
          name: 'pgweb'
          image: 'docker.io/sosedoff/pgweb:latest'
          command: [
            '/bin/sh'
          ]
          args: [
            '-c'
            'PGWEB_DATABASE_URL=$POSTGRES_URL /usr/bin/pgweb --bind=0.0.0.0 --listen=8081'
          ]
        }
      ]
    }
  }
}

output pgsqlCliExec string = 'az containerapp exec -n ${pgsqlCli.name} -g ${resourceGroup().name} --revision ${pgsqlCli.properties.latestRevisionName} --command /bin/bash'

output postgresLogs string = 'az containerapp logs show -n ${postgres.name} -g ${resourceGroup().name} --follow --tail 30'

output pgwebUrl string = 'https://${pgweb.properties.configuration.ingress.fqdn}'

Usare l'interfaccia della riga di comando di Azure per distribuire il modello.

RESOURCE_GROUP="postgres-dev"
LOCATION="northcentralus"

az group create \
    --name "$RESOURCE_GROUP" \
    --location "$LOCATION"

az deployment group create -g $RESOURCE_GROUP \
    --query 'properties.outputs.*.value' \
    --template-file postgres-dev.bicep

Interfaccia della riga di comando per sviluppatori di Azure

Un modello finale è disponibile in GitHub.

Usare azd up per distribuire il modello.

git clone https://github.com/Azure-Samples/aca-dev-service-postgres-azd
cd aca-dev-service-postgres-azd
azd up

Pulire le risorse

Al termine, eseguire il comando seguente per eliminare il gruppo di risorse contenente le risorse di App contenitore.

Attenzione

Il comando seguente elimina il gruppo di risorse specificato e tutte le risorse contenute all'interno. Se nel gruppo di risorse specificato sono presenti anche risorse diverse da quelle usate in questa esercitazione, verranno eliminate.

az group delete \
    --resource-group $RESOURCE_GROUP