Share via

Tutorial: uso de un servicio PostgreSQL para el desarrollo

  • Artículo

Azure Container Apps permite conectarse a los servicios de desarrollo y de nivel de producción para proporcionar una amplia variedad de funcionalidades a las aplicaciones.

En este tutorial, aprenderá a usar un servicio de PostgreSQL de desarrollo con Container Apps.

Los comandos de la CLI de Azure y los fragmentos de plantilla de Bicep se incluyen en este tutorial. Si usa Bicep, puede agregar todos los fragmentos a un único archivo de Bicep e implementar la plantilla a la vez.

  • Crear un entorno de Container Apps para implementar el servicio y las aplicaciones de contenedor
  • Crear un servicio PostgreSQL
  • Crear y utilizar una aplicación de línea de comandos para utilizar el servicio de PostgreSQL de desarrollo
  • Creación de una aplicación pgweb
  • Escritura de datos en la base de datos de PostgreSQL

Prerrequisitos

Nota

Para una implementación con un solo comando, vaya al último azdpaso de la plantilla.

Configurar

  1. Defina variables para valores comunes.

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

  2. Inicie sesión en Azure.

    az login

  3. Actualice la CLI a la última versión.

    az upgrade

  4. Actualice a la versión más reciente de Bicep.

    az bicep upgrade

  5. Agregue la extensión containerapp.

    az extension add --name containerapp --upgrade

  6. Registre espacios de nombres necesarios.

    az provider register --namespace Microsoft.App

    az provider register --namespace Microsoft.OperationalInsights

Creación de un entorno de Container Apps

  1. Cree un grupo de recursos.

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

  2. Creación de un entorno de Container Apps.

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

Crear un servicio PostgreSQL

  1. Crear un servicio de PostgreSQL.

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

  2. Ver la salida del registro desde la instancia de Postgres

    Use el comando logs para ver los mensajes de registro.

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

    Captura de pantalla de los registros del servicio PostgreSQL de la aplicación de contenedor.

Creación de una aplicación para probar el servicio

Al crear la aplicación, empiece por crear una aplicación de depuración para usar la CLI de psql para conectarse a la instancia de PostgreSQL.

  1. Creación de una app de psql que se conecta al servicio de 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. Ejecute el comando exec de la CLI para conectarse a la aplicación de prueba.

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

    Al usar --bind o serviceBinds en la aplicación de prueba, la información de conexión se inserta en el entorno de la aplicación. Una vez que se conecte al contenedor de prueba, puede inspeccionar los valores mediante el comando env.

    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. Utilice psql para conectarse al servicio

    psql $POSTGRES_URL

    Captura de pantalla de la aplicación contenedora que utiliza pgsql para conectarse a un servicio PostgreSQL.

  4. Cree una tabla llamada accounts e inserte datos.

    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 pantalla de la app contenedora que utiliza pgsql para conectarse a PostgreSQL y crear una tabla e insertar algunos datos.

Uso de un servicio dev con una app existente

Si ya tiene una aplicación que usa PostgreSQL, puede cambiar cómo se carga la información de conexión.

Primero, agregue las siguientes variables de entorno.

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...

Luego, mediante la CLI (o Bicep) puede actualizar la aplicación para añadir --bind $PG_SVC para usar el servicio de desarrollo.

Enlace al servicio de desarrollo

Implemente pgweb para ver y administrar la instancia de PostgreSQL.

Vea Bicep o el ejemplo de azd.

Captura de pantalla de la Container App de pgweb conectándose al servicio PostgreSQL.

Implementar todos los recursos

Use los ejemplos siguientes si desea implementar todos los recursos a la vez.

Bicep

La siguiente plantilla de Bicep contiene todos los recursos de este tutorial.

Puede crear un archivo postgres-dev.bicep con este contenido.

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 la CLI de Azure para implementarla en la plantilla.

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

CLI de desarrollo de Azure

Una plantilla final está disponible en GitHub.

Use azd up para implementar la plantilla.

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

Limpieza de recursos

Cuando haya terminado, ejecute el siguiente comando para eliminar el grupo de recursos que contiene los recursos de Container Apps.

Precaución

El comando siguiente elimina el grupo de recursos especificado y todos los recursos que contiene. Si existen recursos en el grupo de recursos especificado que están fuera del ámbito de este tutorial, también se eliminarán.

az group delete \
    --resource-group $RESOURCE_GROUP