Tutorial: Creación y uso de un servicio de Apache Kafka para el desarrollo

Artículo
06/25/2023

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 crear y usar un servicio de Apache Kafka de desarrollo.

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.

Creación de un entorno de Container Apps para implementar el servicio y la aplicación de contenedor
Creación de un servicio de Apache Kafka
Configuración de una aplicación de línea de comandos para usar el servicio de desarrollo Apache Kafka
Implementación de una aplicación kafka-ui para ver datos de la aplicación
Compilación de una plantilla de Bicep final para implementar todos los recursos mediante una implementación de plantilla coherente y predecible
Utilización de una plantilla azd para la implementación de todos los recursos con un solo comando

Prerrequisitos

Instale la CLI de Azure.
Opcional: Azure Developer CLI para seguir las instrucciones de AZD.

Nota

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

Configurar

Defina variables para valores comunes.

RESOURCE_GROUP="kafka-dev"
LOCATION="northcentralus"
ENVIRONMENT="aca-env"
KAFKA_SVC="kafka01"
KAFKA_CLI_APP="kafka-cli-app"
KAFKA_UI_APP="kafka-ui-app"

Las siguientes variables permiten usar la CLI para implementar la plantilla de Bicep.

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

Para Bicep, empiece por crear un archivo llamado kafka-dev.bicep. A continuación, añádale parámetros con los siguientes valores por defecto.

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'

A medida que implemente la plantilla de bicep en cualquier fase, puede usar el comando az deployment group create.

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

Defina las variables iniciales.

AZURE_ENV_NAME="azd-kafka-dev"
LOCATION="northcentralus"

Use los valores para inicializar una plantilla de azd mínima.

azd init \
    --environment "$AZURE_ENV_NAME" \
    --location "$LOCATION" \
    --no-prompt

Nota:

AZURE_ENV_NAME es diferente del nombre del entorno de Aplicación de contenedor. En este contexto, AZURE_ENV_NAME en azd es para todos los recursos de una plantilla. Estos recursos incluyen recursos que no están asociados a Container Apps. Cree un nombre diferente para el entorno de Container Apps.

A continuación, cree infra/main.bicep y defina parámetros para su uso posterior.

param appEnvironmentName string = 'aca-env'
param kafkaSvcName string = 'kafka01'
param kafkaCliAppName string = 'kafka-cli-app'
param kafkaUiAppName string = 'kafka-ui'

Inicie sesión en Azure.
```
az login
```
Actualice la CLI a la última versión.
```
az upgrade
```
Actualice a la versión más reciente de Bicep.
```
az bicep upgrade
```

Agregue la extensión containerapp.

az extension add --name containerapp --upgrade

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

Cree un grupo de recursos.
- Bash
- Bicep
- azd
```
az group create \
    --name "$RESOURCE_GROUP" \
    --location "$LOCATION"
```
```
az group create \
    --name "$RESOURCE_GROUP" \
    --location "$LOCATION"
```
No se necesita ninguna configuración especial para administrar grupos de recursos en azd. El comando azd obtiene el grupo de recursos del valor AZURE_ENV_NAME/--environment.

Puede probar la plantilla mínima con el comando up.
```
azd up
```
Al ejecutar este comando se crea un grupo de recursos vacío.

Creación de un entorno de Container Apps.

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

Agregue los siguientes valores al archivo kafka-dev.bicep.

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

La CLI de Azure crea automáticamente un espacio de trabajo de Log Analytics para cada entorno. Para generar un área de trabajo mediante una plantilla de Bicep, declare explícitamente el entorno y vincule a él en la plantilla. Este paso hace que la implementación sea más estable, aunque a costa de ser un poco detallado.

Agregue los siguientes valores al entorno.

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

Las plantillas usadas por azd usan módulos de bicep.

Cree una carpeta denominada ./infra/core/hosty, a continuación, cree un módulo ./infra/core/host/container-apps-environment.bicep con el siguiente contenido.

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

En el archivo ./infra/main.bicep, cargue el módulo con los valores siguientes.

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

Ejecute azd up para implementar la plantilla.

Creación de un servicio de Apache Kafka

Creación de un servicio de Apache Kafka.

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

Agregue los valores siguientes a 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'

Cree un archivo de módulo de ./infra/core/host/container-app-service.bicep con el siguiente contenido.

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

A continuación, actualice el módulo ./infra/main.bicep con la siguiente declaración.

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

Implemente la plantilla.

    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

Sugerencia

La salida kafkaLogs genera un comando de la CLI para ayudarle a ver los registros de kafka una vez completada la implementación. Puede ejecutar el comando para ver los registros de inicialización del nuevo servicio Kafka.

`azd up`

Ver la salida del registro desde la instancia de Kafka

Use el comando logs para ver los mensajes de registro.

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

En el ejemplo anterior de Bicep se incluye la salida para un comando para ver los registros.

Por ejemplo:

[
  "az containerapp logs show -n kafka01 -g kafka-dev --follow --tail 30"
]

Si no tiene el comando, puede usar el nombre del servicio para ver los registros mediante la CLI.

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

Use el comando logs para ver los mensajes de registro.

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

Captura de pantalla de los registros del servicio Kafka de Container App.

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

Al crear la aplicación, la configurará para usar ./kafka-topics.sh, ./kafka-console-producer.sh y kafka-console-consumer.sh para conectarse a la instancia de Kafka.

Cree una aplicación kafka-cli-app que se enlace al servicio 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"

Agregue lo siguiente a los valores 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'

Sugerencia

La salida kafkaCliExec genera un comando de la CLI que puede ejecutar para comprobar que la aplicación está implementada correctamente.

Cree un módulo en ./infra/core/host/container-app.bicep y añada los siguientes valores.

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

Ahora, use el módulo en ./infra/main.bicep agregando los valores siguientes.

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

Implemente la plantilla con azd up.

azd up

Ejecute el comando exec de la CLI para conectarse a la aplicación de prueba.

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

En el ejemplo anterior de Bicep se incluye la salida que muestra cómo ejecutar la aplicación.

Por ejemplo:

[
  "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 no tiene el comando, puede usar el nombre de la aplicación para ejecutarla mediante el comando 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

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 "^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

Use kafka-topics.sh para crear un tema de evento.

Cree un archivo 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

Cree un tema del evento 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

Use kafka-console-producer.sh para escribir algunos eventos en el tema.

/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

Nota

El comando ./kafka-console-producer.sh le pide que escriba eventos con >. Escriba algunos eventos como se muestra y, a continuación, presione CTRL-C para salir.

Use kafka-console-consumer.sh para leer eventos del tema.

/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

Captura de pantalla de los registros de salida de la Container App de la CLI Kafka.

Uso de un servicio de desarrollo con una aplicación existente

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

Primero, agregue las siguientes variables de entorno.

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

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

Enlace al servicio de desarrollo

Implemente kafka-ui para ver y administrar la instancia de Kafka.

Vea Bicep o el ejemplo de 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}'

El comando de Bicep devuelve una dirección URL. Copie esta dirección URL en el explorador para visitar el sitio implementado.

Actualice ./infra/main.bicep con los siguientes valores.

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

Implemente la plantilla con azd up.

azd up

Captura de pantalla de pgweb Container App que se conecta al servicio Kafka.

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 kafka-dev.bicep con este contenido.

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'

Use la CLI de Azure para implementarla en la plantilla.

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

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-kafka-azd
cd aca-dev-service-kafka-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

Share via