Partager via

Tutoriel : Utiliser un service PostgreSQL pour le développement

  • Article

Azure Container Apps vous permet de vous connecter à des services de développement et de production pour fournir une grande variété de fonctionnalités à vos applications.

Dans ce tutoriel, vous allez apprendre à utiliser un service PostgreSQL de développement avec Container Apps.

Les commandes Azure CLI et les fragments de modèle Bicep sont présentés dans ce tutoriel. Si vous utilisez Bicep, vous pouvez ajouter tous les fragments à un seul fichier Bicep et déployer le modèle en même temps.

  • Créer un environnement Container Apps pour déployer vos applications de service et de conteneur
  • Créer un service PostgreSQL
  • Créez et utilisez une application en ligne de commande pour utiliser le service dev PostgreSQL
  • Créez une application pgweb
  • Écrivez des données dans la base de données PostgreSQL

Prérequis

Notes

Pour un déploiement de commande, passez à la dernière azdétape du modèle.

Programme d’installation

  1. Définissez des variables pour les valeurs communes.

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

  2. Connectez-vous à Azure.

    az login

  3. Effectuez une mise à niveau de l'interface CLI vers la version la plus récente.

    az upgrade

  4. Effectuez une mise à niveau de Bicep vers la version la plus récente.

    az bicep upgrade

  5. Ajoutez l’extension containerapp.

    az extension add --name containerapp --upgrade

  6. Inscrivez les espaces de noms requis.

    az provider register --namespace Microsoft.App

    az provider register --namespace Microsoft.OperationalInsights

Créer un environnement Container Apps

  1. Créez un groupe de ressources.

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

  2. Créez un environnement Container Apps.

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

Créer un service PostgreSQL

  1. Créez un service PostgreSQL.

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

  2. Affichez la sortie du journal à partir de l’instance Postgres

    Utilisez la commande logs pour afficher les messages du journal.

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

    Capture d’écran des journaux du service PostgreSQL d’une application de conteneur.

Créez une application pour tester le service

Lorsque vous créez l’application, vous commencez par créer une application de débogage pour utiliser l’interface CLI psql afin de vous connecter à l’instance PostgreSQL.

  1. Créer une application psql qui se lie au service 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. Exécutez la commande CLI exec pour vous connecter à l’application de test.

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

    Lorsque vous utilisez --bind ou serviceBinds dans l’application de test, les informations de connexion sont injectées dans l’environnement de l’application. Une fois que vous vous êtes connecté au conteneur de test, vous pouvez inspecter les valeurs à l’aide de la commande 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. Utilisez psql pour vous connecter au service

    psql $POSTGRES_URL

    Capture d'écran de l'application de conteneur utilisant pgsql pour se connecter à un service PostgreSQL.

  4. Créez un tableau nommé accounts et insérez des données.

    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;

    Capture d'écran de l'application de conteneur utilisant pgsql pour se connecter à PostgreSQL, créer une table et ajouter des données.

Utilisation d’un service de développement avec une application existante

Si vous disposez déjà d’une application qui utilise PostgreSQL, vous pouvez modifier le mode de chargement des informations de connexion.

Tout d’abord, créez les variables d’environnement suivantes.

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

A l’aide de l’interface CLI (ou Bicep) vous pouvez mettre à jour l’application pour ajouter --bind $PG_SVC afin d’utiliser le service dev.

Liaison au service de développement

Déployez pgweb pour afficher et gérer les instance PostgreSQL.

Consultez Bicep ou l’exemple azd.

Capture d'écran de l'application de conteneur pgweb se connectant au service PostgreSQL.

Déployez toutes les ressources

Utilisez les exemples suivants si vous souhaitez déployer toutes les ressources en même temps.

Bicep

Le modèle Bicep suivant contient toutes les ressources de ce tutoriel.

Vous pouvez créer un fichier postgres-dev.bicep avec le contenu suivant.

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

Utilisez Azure CLI pour déployer le modèle.

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

Un modèle final est disponible sur GitHub.

Utilisez azd up pour déployer le modèle.

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

Nettoyer les ressources

Une fois que vous avez terminé, exécutez la commande suivante pour supprimer le groupe de ressources qui contient vos ressources Container Apps.

Attention

La commande suivante supprime le groupe de ressources spécifié et toutes les ressources qu’il contient. Si des ressources en dehors du cadre de ce tutoriel existent dans le groupe de ressources spécifié, elles seront également supprimées.

az group delete \
    --resource-group $RESOURCE_GROUP