Partilhar via

Tutorial: Usar um serviço PostgreSQL para desenvolvimento

  • Artigo

Os Aplicativos de Contêiner do Azure permitem que você se conecte a serviços de desenvolvimento e nível de produção para fornecer uma ampla variedade de funcionalidades para seus aplicativos.

Neste tutorial, você aprenderá a usar um serviço PostgreSQL de desenvolvimento com Container Apps.

Os comandos da CLI do Azure e os fragmentos de modelo Bicep são apresentados neste tutorial. Se você usar o Bicep, poderá adicionar todos os fragmentos a um único arquivo Bicep e implantar o modelo de uma só vez.

  • Criar um ambiente de aplicativos de contêiner para implantar seus aplicativos de serviço e contêiner
  • Criar um serviço PostgreSQL
  • Criar e usar um aplicativo de linha de comando para usar o serviço dev PostgreSQL
  • Criar um aplicativo pgweb
  • Gravar dados no banco de dados PostgreSQL

Pré-requisitos

  • Instale a CLI do Azure.
  • Opcional: CLI do Desenvolvedor do Azure para seguir as instruções do AZD.

Nota

Para uma implantação de um comando, pule para a última azd etapa do modelo.

Configurar

  1. Definir variáveis para valores comuns.

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

  2. Iniciar sessão no Azure.

    az login

  3. Atualize a CLI para a versão mais recente.

    az upgrade

  4. Atualize o Bicep para a versão mais recente.

    az bicep upgrade

  5. Adicionar extensão th containerapp .

    az extension add --name containerapp --upgrade

  6. Registre os namespaces necessários.

    az provider register --namespace Microsoft.App

    az provider register --namespace Microsoft.OperationalInsights

Criar um ambiente de aplicativos de contêiner

  1. Crie um grupo de recursos.

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

  2. Crie um ambiente de aplicativos de contêiner.

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

Criar um serviço PostgreSQL

  1. Crie um serviço PostgreSQL.

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

  2. Exibir saída de log da instância do Postgres

    Use o comando para exibir mensagens de logs log.

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

    Captura de tela dos logs de serviço PostgreSQL do aplicativo contêiner.

Criar um aplicativo para testar o serviço

Ao criar o aplicativo, você começa criando um aplicativo de depuração para usar a psql CLI para se conectar à instância do PostgreSQL.

  1. Crie um psql aplicativo que se vincule ao serviço 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. Execute o comando CLI exec para se conectar ao aplicativo de teste.

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

    Quando você usa --bind ou serviceBinds no aplicativo de teste, as informações de conexão são injetadas no ambiente do aplicativo. Depois de se conectar ao contêiner de teste, você pode inspecionar os valores usando o 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. Nós psql para nos conectarmos ao serviço

    psql $POSTGRES_URL

    Captura de tela do aplicativo de contêiner usando pgsql para se conectar a um serviço PostgreSQL.

  4. Crie uma tabela com o nome accounts e insira dados.

    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;

    Captura de tela do aplicativo de contêiner usando pgsql conectar-se ao PostgreSQL e criar uma tabela e semear alguns dados.

Usando um serviço de desenvolvimento com um aplicativo existente

Se você já tiver um aplicativo que usa PostgreSQL, poderá alterar a forma como as informações de conexão são carregadas.

Primeiro, crie as seguintes variáveis de ambiente.

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 a CLI (ou Bicep), você pode atualizar o aplicativo a ser adicionado --bind $PG_SVC para usar o serviço de desenvolvimento.

Vinculação ao serviço de desenvolvimento

Implante o pgweb para exibir e gerenciar a instância do PostgreSQL.

Veja Bicep ou azd exemplo.

Captura de tela do aplicativo de contêiner pgweb conectando-se ao serviço PostgreSQL.

Implantar todos os recursos

Use os exemplos a seguir para se quiser implantar todos os recursos de uma só vez.

Bicep

O modelo Bicep a seguir contém todos os recursos neste tutorial.

Você pode criar um postgres-dev.bicep arquivo com esse conteúdo.

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}'

Use a CLI do Azure para implantar o modelo.

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

Azure Developer CLI

Um modelo final está disponível no GitHub.

Use azd up para implantar o modelo.

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

Clean up resources (Limpar recursos)

Quando terminar, execute o seguinte comando para excluir o grupo de recursos que contém os recursos dos Aplicativos de Contêiner.

Atenção

O comando a seguir exclui o grupo de recursos especificado e todos os recursos contidos nele. Se existirem recursos fora do escopo deste tutorial no grupo de recursos especificado, eles também serão excluídos.

az group delete \
    --resource-group $RESOURCE_GROUP