Tutoriel : Créer et utiliser un service Apache Kafka pour le développement

Article
06/28/2023

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 à créer et à utiliser un service Apache Kafka de développement.

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éez un environnement Container Apps pour déployer vos applications de conteneur
Créer un service Apache Kafka
Configurez une application en ligne de commande pour utiliser le service dev Apache Kafka
Déployez une application kafka-ui pour afficher les données de l’application
Compiler un modèle bicep final pour déployer toutes les ressources à l’aide d’un déploiement de modèle cohérent et prévisible
Utiliser un modèle azd pour un déploiement à une seule commande de toutes les ressources

Prérequis

Installez Azure CLI.
Facultatif : Azure Developer CLI pour suivre les instructions AZD.

Notes

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

Programme d’installation

Définissez des variables pour les valeurs communes.
- Bash
- Bicep
- azd
```
RESOURCE_GROUP="kafka-dev"
LOCATION="northcentralus"
ENVIRONMENT="aca-env"
KAFKA_SVC="kafka01"
KAFKA_CLI_APP="kafka-cli-app"
KAFKA_UI_APP="kafka-ui-app"
```
Les variables suivantes vous permettent d’utiliser l’interface CLI pour déployer le modèle Bicep.
```
RESOURCE_GROUP="kafka-dev"
LOCATION="northcentralus"
```
Pour Bicep, commencez par créer un fichier appelé kafka-dev.bicep, puis ajoutez des paramètres avec les valeurs par défaut suivantes.
```
targetScope = 'resourceGroup'
param location string = resourceGroup().location
param appEnvironmentName string = 'aca-env'
param kafkaSvcName string = 'kafka01'
param kafkaCliAppName string = 'kafka-cli-app'
param kafkaUiAppName string = 'kafka-ui'
```
Lorsque vous déployez le modèle bicep à n’importe quel stade, vous pouvez utiliser la commande az deployment group create.
```
az deployment group create -g $RESOURCE_GROUP \
    --query 'properties.outputs.*.value' \
    --template-file kafka-dev.bicep
```
Définissez vos variables initiales.
```
AZURE_ENV_NAME="azd-kafka-dev"
LOCATION="northcentralus"
```
Utilisez les valeurs pour initialiser un modèle minimal azd.
```
azd init \
    --environment "$AZURE_ENV_NAME" \
    --location "$LOCATION" \
    --no-prompt
```
Notes

AZURE_ENV_NAME est différent du nom de l’environnement de Container App. Dans ce contexte, AZURE_ENV_NAME dans azd s’applique à toutes les ressources d’un modèle. Ces ressources incluent des ressources qui ne sont pas associées à Container Apps. Vous créez un nom différent pour l’environnement Container Apps.

Ensuite, créez infra/main.bicep et définissez des paramètres pour une utilisation ultérieure.
```
param appEnvironmentName string = 'aca-env'
param kafkaSvcName string = 'kafka01'
param kafkaCliAppName string = 'kafka-cli-app'
param kafkaUiAppName string = 'kafka-ui'
```
Connectez-vous à Azure.
```
az login
```
Effectuez une mise à niveau de l'interface CLI vers la version la plus récente.
```
az upgrade
```
Effectuez une mise à niveau de Bicep vers la version la plus récente.
```
az bicep upgrade
```

Ajoutez l’extension containerapp.

az extension add --name containerapp --upgrade

Inscrivez les espaces de noms requis.

az provider register --namespace Microsoft.App

az provider register --namespace Microsoft.OperationalInsights

Créer un environnement Container Apps

Créez un groupe de ressources.
- Bash
- Bicep
- azd
```
az group create \
    --name "$RESOURCE_GROUP" \
    --location "$LOCATION"
```
```
az group create \
    --name "$RESOURCE_GROUP" \
    --location "$LOCATION"
```
Aucune configuration spéciale n’est nécessaire pour la gestion des groupes de ressources dans azd. La commande azd obtient le groupe de ressources à partir de la valeur AZURE_ENV_NAME/--environment.

Vous pouvez tester le modèle minimal avec la commande up.
```
azd up
```
L’exécution de cette commande crée un groupe de ressources vide.

Créez un environnement Container Apps.

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

Ajoutez les valeurs suivantes à votre fichier kafka-dev.bicep.

resource appEnvironment 'Microsoft.App/managedEnvironments@2023-04-01-preview' = {
  name: appEnvironmentName
  location: location
  properties: {
    appLogsConfiguration: {
      destination: 'azure-monitor'
    }
  }
}

Azure CLI crée automatiquement un espace de travail Log Analytics pour chaque environnement. Pour générer un espace de travail à l’aide d’un modèle Bicep, vous déclarez explicitement l’environnement et créez un lien vers celui-ci dans le modèle. Cette étape rend votre déploiement plus stable, même si elle est un peu détaillée.

Ajoutez les valeurs suivantes à votre environnement.

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

Les modèles utilisés par azd utilisent des modules bicep.

Créez un dossier nommé ./infra/core/host, puis créez un module ./infra/core/host/container-apps-environment.bicep avec le contenu suivant.

param name string
param location string = resourceGroup().location
param tags object = {}

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

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

output appEnvironmentId string = appEnvironment.id

Dans le fichier ./infra/main.bicep, chargez le module à l’aide des valeurs suivantes.

module appEnvironment './core/host/container-apps-environment.bicep' = {
  name: 'appEnvironment'
  scope: rg
  params: {
    name: appEnvironmentName
    location: location
    tags: tags
  }
}

Exécutez azd up pour déployer le modèle.

Créer un service Apache Kafka

Créez un service Apache Kafka.

ENVIRONMENT_ID=$(az containerapp env show \
  --name "$ENVIRONMENT" \
  --resource-group "$RESOURCE_GROUP" \
  --output tsv \
  --query id)

Ajoutez les valeurs suivantes à kafka-dev.bicep.

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

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

Créez un fichier de module ./infra/core/host/container-app-service.bicep avec le contenu suivant.

param name string
param location string = resourceGroup().location
param tags object = {}
param environmentId string
param serviceType string


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

output serviceId string = service.id

Ensuite, mettez à jour ./infra/main.bicep pour utiliser le module avec la déclaration suivante.

module kafka './core/host/container-app-service.bicep' = {
  name: 'kafka'
  scope: rg
  params: {
    name: kafkaSvcName
    location: location
    tags: tags
    environmentId: appEnvironment.outputs.appEnvironmentId
    serviceType: 'kafka'
  }
}

Déployez le modèle.

    az containerapp add-on kafka create \
    --name "$KAFKA_SVC" \
    --resource-group "$RESOURCE_GROUP" \
    --environment "$ENVIRONMENT"

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

Conseil

La sortie kafkaLogs génère une commande CLI pour vous aider à afficher les journaux de kafka une fois le déploiement terminé. Vous pouvez exécuter la commande pour afficher les journaux d’initialisation du nouveau service Kafka.

`azd up`

Affichez la sortie du journal à partir de l’instance Kafka
- Bash
- Bicep
- azd
Utilisez la commande logs pour afficher les messages du journal.
```
az containerapp logs show \
    --name $KAFKA_SVC \
    --resource-group $RESOURCE_GROUP \
    --follow --tail 30
```
L’exemple Bicep précédent inclut la sortie d’une commande permettant d’afficher les journaux.

Par exemple :
```
[
  "az containerapp logs show -n kafka01 -g kafka-dev --follow --tail 30"
]
```
Si vous ne disposez pas de la commande, vous pouvez utiliser le nom du service pour consulter les journaux à l’aide de l’interface CLI.
```
az containerapp logs show \
    --name $KAFKA_SVC \
    --resource-group $RESOURCE_GROUP \
    --follow --tail 30
```
Utilisez la commande logs pour afficher les messages du journal.
```
az containerapp logs show \
    --name kafka01 \
    --resource-group $RESOURCE_GROUP \
    --follow --tail 30
```

Créez une application pour tester le service

Lorsque vous créez l’application, vous la configurez pour utiliser ./kafka-topics.sh, ./kafka-console-producer.sh et kafka-console-consumer.sh pour se connecter à l’instance Kafka.

Créer une application kafka-cli-app qui se lie au service Kafka.

az containerapp create \
    --name "$KAFKA_CLI_APP" \
    --image mcr.microsoft.com/k8se/services/kafka:3.4 \
    --bind "$KAFKA_SVC" \
    --environment "$ENVIRONMENT" \
    --resource-group "$RESOURCE_GROUP" \
    --min-replicas 1 \
    --max-replicas 1 \
    --command "/bin/sleep" "infinity"

Ajouter les éléments suivants aux valeurs kafka-dev.bicep.

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

output kafkaCliExec string = 'az containerapp exec -n ${kafkaCli.name} -g ${resourceGroup().name} --command /bin/bash'

Conseil

La sortie kafkaCliExec génère une commande CLI que vous pouvez exécuter pour vérifier que l’application est déployée correctement.

Créez un module sous ./infra/core/host/container-app.bicep et ajoutez les valeurs suivantes.

param name string
param location string = resourceGroup().location
param tags object = {}

param environmentId string
param serviceId string = ''
param containerName string
param containerImage string
param containerCommands array = []
param containerArgs array = []
param minReplicas int
param maxReplicas int
param targetPort int = 0
param externalIngress bool = false

resource app 'Microsoft.App/containerApps@2023-04-01-preview' = {
  name: name
  location: location
  tags: tags
  properties: {
    environmentId: environmentId
    configuration: {
      ingress: targetPort > 0 ? {
        targetPort: targetPort
        external: externalIngress
      } : null
    }
    template: {
      serviceBinds: !empty(serviceId) ? [
        {
          serviceId: serviceId
        }
      ] : null
      containers: [
        {
          name: containerName
          image: containerImage
          command: !empty(containerCommands) ? containerCommands : null
          args: !empty(containerArgs) ? containerArgs : null
        }
      ]
      scale: {
        minReplicas: minReplicas
        maxReplicas: maxReplicas
      }
    }
  }
}

Utilisez maintenant le module en ./infra/main.bicep en ajoutant les valeurs suivantes.

module kafkaCli './core/host/container-app.bicep' = {
  name: 'kafkaCli'
  scope: rg
  params: {
    name: kafkaCliAppName
    location: location
    tags: tags
    environmentId: appEnvironment.outputs.appEnvironmentId
    serviceId: kafka.outputs.serviceId
    containerImage: 'mcr.microsoft.com/k8se/services/kafka:3.4'
    containerName: 'kafka-cli'
    maxReplicas: 1
    minReplicas: 1
    containerCommands: [ '/bin/sleep', 'infinity' ]
  }
}

Déployez le modèle en utilisant azd up.

azd up

Exécutez la commande CLI exec pour vous connecter à l’application de test.

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

L’exemple Bicep précédent inclut une sortie qui vous montre comment exécuter l’application.

Par exemple :

[
  "az containerapp logs show -n kafka01 -g kafka-dev --follow --tail 30",
  "az containerapp exec -n kafka-cli-app -g kafka-dev --command /bin/bash"
]

Si vous ne disposez pas de la commande, vous pouvez utiliser le nom de l’application pour lancer l’application à l’aide de la commande exec.

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

az containerapp exec \
    --name kafka-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 "^KAFKA_"

KAFKA_SECURITYPROTOCOL=SASL_PLAINTEXT
KAFKA_BOOTSTRAPSERVER=kafka01:9092
KAFKA_HOME=/opt/kafka
KAFKA_PROPERTIES_SASL_JAAS_CONFIG=org.apache.kafka.common.security.plain.PlainLoginModule required username="kafka-user" password="7dw..." user_kafka-user="7dw..." ;
KAFKA_BOOTSTRAP_SERVERS=kafka01:9092
KAFKA_SASLUSERNAME=kafka-user
KAFKA_SASL_USER=kafka-user
KAFKA_VERSION=3.4.0
KAFKA_SECURITY_PROTOCOL=SASL_PLAINTEXT
KAFKA_SASL_PASSWORD=7dw...
KAFKA_SASLPASSWORD=7dw...
KAFKA_SASL_MECHANISM=PLAIN
KAFKA_SASLMECHANISM=PLAIN

Utilisez kafka-topics.sh pour créer une rubrique d’événement.

Créez un fichier kafka.props .

echo "security.protocol=$KAFKA_SECURITY_PROTOCOL" >> kafka.props && \
echo "sasl.mechanism=$KAFKA_SASL_MECHANISM" >> kafka.props && \
echo "sasl.jaas.config=$KAFKA_PROPERTIES_SASL_JAAS_CONFIG" >> kafka.props

Créez une rubrique d’événement quickstart-events.

/opt/kafka/bin/kafka-topics.sh \
    --create --topic quickstart-events \
    --bootstrap-server $KAFKA_BOOTSTRAP_SERVERS \
    --command-config kafka.props
# Created topic quickstart-events.

/opt/kafka/bin/kafka-topics.sh \
    --describe --topic quickstart-events \
    --bootstrap-server $KAFKA_BOOTSTRAP_SERVERS \
    --command-config kafka.props
# Topic: quickstart-events	TopicId: lCkTKmvZSgSUCHozhhvz1Q	PartitionCount: 1	ReplicationFactor: 1	Configs: segment.bytes=1073741824
# Topic: quickstart-events	Partition: 0	Leader: 1	Replicas: 1	Isr: 1

Utilisez kafka-console-producer.sh pour écrire des événements dans la rubrique.
```
/opt/kafka/bin/kafka-console-producer.sh \
    --topic quickstart-events \
    --bootstrap-server $KAFKA_BOOTSTRAP_SERVERS \
    --producer.config kafka.props

> this is my first event
> this is my second event
> this is my third event
> CTRL-C
```
Notes

La commande ./kafka-console-producer.sh vous invite à écrire des événements avec >. Écrivez quelques événements comme indiqué, puis appuyez sur CTRL-C pour quitter.

Utiliser kafka-console-consumer.sh pour lire les événements de la rubrique.

/opt/kafka/bin/kafka-console-consumer.sh \
     --topic quickstart-events \
    --bootstrap-server $KAFKA_BOOTSTRAP_SERVERS \
    --from-beginning \
    --consumer.config kafka.props

# this is my first event
# this is my second event
# this is my third event

Capture d’écran des journaux de sortie CLI Kafka d’une application de conteneur.

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

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

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

KAFKA_HOME=/opt/kafka
KAFKA_PROPERTIES_SASL_JAAS_CONFIG=org.apache.kafka.common.security.plain.PlainLoginModule required username="kafka-user" password="7dw..." user_kafka-user="7dw..." ;
KAFKA_BOOTSTRAP_SERVERS=kafka01:9092
KAFKA_SASL_USER=kafka-user
KAFKA_VERSION=3.4.0
KAFKA_SECURITY_PROTOCOL=SASL_PLAINTEXT
KAFKA_SASL_PASSWORD=7dw...
KAFKA_SASL_MECHANISM=PLAIN

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

Liaison au service de développement

Déployez kafka-ui pour afficher et gérer les instance Kafka.

Consultez Bicep ou l’exemple azd.

resource kafkaUi 'Microsoft.App/containerApps@2023-04-01-preview' = {
  name: kafkaUiAppName
  location: location
  properties: {
    environmentId: appEnvironment.id
    configuration: {
      ingress: {
        external: true
        targetPort: 8080
      }
    }
    template: {
      serviceBinds: [
        {
          serviceId: kafka.id
          name: 'kafka'
        }
      ]
      containers: [
        {
          name: 'kafka-ui'
          image: 'docker.io/provectuslabs/kafka-ui:latest'
          command: [
            '/bin/sh'
          ]
          args: [
            '-c'
            '''export KAFKA_CLUSTERS_0_BOOTSTRAPSERVERS="$KAFKA_BOOTSTRAP_SERVERS" && \
            export KAFKA_CLUSTERS_0_PROPERTIES_SASL_JAAS_CONFIG="$KAFKA_PROPERTIES_SASL_JAAS_CONFIG" && \
            export KAFKA_CLUSTERS_0_PROPERTIES_SASL_MECHANISM="$KAFKA_SASL_MECHANISM" && \
            export KAFKA_CLUSTERS_0_PROPERTIES_SECURITY_PROTOCOL="$KAFKA_SECURITY_PROTOCOL" && \
            java $JAVA_OPTS -jar kafka-ui-api.jar'''
          ]
          resources: {
            cpu: json('1.0')
            memory: '2.0Gi'
          }
        }
      ]
    }
  }
}

output kafkaUiUrl string = 'https://${kafkaUi.properties.configuration.ingress.fqdn}'

La commande Bicep renvoie une URL. Copiez cette URL dans votre navigateur pour visiter le site déployé.

Mettez à jour ./infra/main.bicep à l’aide des valeurs suivantes.

module kafkaUi './core/host/container-app.bicep' = {
  name: 'kafka-ui'
  scope: rg
  params: {
    name: kafkaUiAppName
    location: location
    tags: tags
    environmentId: appEnvironment.outputs.appEnvironmentId
    serviceId: kafka.outputs.serviceId
    containerImage: 'docker.io/provectuslabs/kafka-ui:latest'
    containerName: 'kafka-ui'
    maxReplicas: 1
    minReplicas: 1
    containerCommands: [ '/bin/sh' ]
    containerArgs: [ 
      '-c'
      '''export KAFKA_CLUSTERS_0_BOOTSTRAPSERVERS="$KAFKA_BOOTSTRAP_SERVERS" && \
      export KAFKA_CLUSTERS_0_PROPERTIES_SASL_JAAS_CONFIG="$KAFKA_PROPERTIES_SASL_JAAS_CONFIG" && \
      export KAFKA_CLUSTERS_0_PROPERTIES_SASL_MECHANISM="$KAFKA_SASL_MECHANISM" && \
      export KAFKA_CLUSTERS_0_PROPERTIES_SECURITY_PROTOCOL="$KAFKA_SECURITY_PROTOCOL" && \
      java $JAVA_OPTS -jar kafka-ui-api.jar'''
    ]
    targetPort: 8080
    externalIngress: true
  }
}

Déployez le modèle en utilisant azd up.

azd up

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

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 kafka-dev.bicep avec le contenu suivant.

targetScope = 'resourceGroup'
param location string = resourceGroup().location
param appEnvironmentName string = 'aca-env'
param kafkaSvcName string = 'kafka01'
param kafkaCliAppName string = 'kafka-cli-app'
param kafkaUiAppName string = 'kafka-ui'

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 kafka 'Microsoft.App/containerApps@2023-04-01-preview' = {
  name: kafkaSvcName
  location: location
  properties: {
    environmentId: appEnvironment.id
    configuration: {
      service: {
          type: 'kafka'
      }
    }
  }
}

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

resource kafkaUi 'Microsoft.App/containerApps@2023-04-01-preview' = {
  name: kafkaUiAppName
  location: location
  properties: {
    environmentId: appEnvironment.id
    configuration: {
      ingress: {
        external: true
        targetPort: 8080
      }
    }
    template: {
      serviceBinds: [
        {
          serviceId: kafka.id
          name: 'kafka'
        }
      ]
      containers: [
        {
          name: 'kafka-ui'
          image: 'docker.io/provectuslabs/kafka-ui:latest'
          command: [
            '/bin/sh'
          ]
          args: [
            '-c'
            '''export KAFKA_CLUSTERS_0_BOOTSTRAPSERVERS="$KAFKA_BOOTSTRAP_SERVERS" && \
            export KAFKA_CLUSTERS_0_PROPERTIES_SASL_JAAS_CONFIG="$KAFKA_PROPERTIES_SASL_JAAS_CONFIG" && \
            export KAFKA_CLUSTERS_0_PROPERTIES_SASL_MECHANISM="$KAFKA_SASL_MECHANISM" && \
            export KAFKA_CLUSTERS_0_PROPERTIES_SECURITY_PROTOCOL="$KAFKA_SECURITY_PROTOCOL" && \
            java $JAVA_OPTS -jar kafka-ui-api.jar'''
          ]
          resources: {
            cpu: json('1.0')
            memory: '2.0Gi'
          }
        }
      ]
    }
  }
}

output kafkaUiUrl string = 'https://${kafkaUi.properties.configuration.ingress.fqdn}'

output kafkaCliExec string = 'az containerapp exec -n ${kafkaCli.name} -g ${resourceGroup().name} --command /bin/bash'

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

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

RESOURCE_GROUP="kafka-dev"
LOCATION="northcentralus"

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

az deployment group create -g $RESOURCE_GROUP \
    --query 'properties.outputs.*.value' \
    --template-file kafka-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-kafka-azd
cd aca-dev-service-kafka-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

Partager via