Esercitazione: Creare e usare un servizio Apache Kafka per lo sviluppo

App Azure Container consente di connettersi a servizi di sviluppo e di livello di produzione per offrire un'ampia gamma di funzionalità alle applicazioni.

In questa esercitazione si apprenderà come creare e usare un servizio Apache Kafka di sviluppo.

I comandi dell'interfaccia della riga di comando di Azure e i frammenti di modello Bicep sono disponibili in questa esercitazione. Se si usa Bicep, è possibile aggiungere tutti i frammenti a un singolo file Bicep e distribuire il modello contemporaneamente.

• Creare un ambiente app contenitore per distribuire il servizio e l'app contenitore
• Creare un servizio Apache Kafka
• Configurare un'app da riga di comando per l'uso del servizio Apache Kafka di sviluppo
• Distribuire un'app kafka-ui per visualizzare i dati dell'applicazione
• Compilare un modello bicep finale per distribuire tutte le risorse usando una distribuzione di modelli coerente e prevedibile
• Usare un azd modello per una distribuzione di un comando di tutte le risorse

Prerequisiti

• Installare l'interfaccia della riga di comando di Azure.
• Facoltativo: interfaccia della riga di comando per sviluppatori di Azure per le istruzioni AZD seguenti.

Nota

Per una distribuzione di un comando, passare all'ultimo azdpassaggio del modello.

Attrezzaggio

1. Definire le variabili per i valori comuni.

   Bash

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

   Bicep

   Le variabili seguenti consentono di usare l'interfaccia della riga di comando per distribuire il modello Bicep.

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

   Per Bicep, iniziare creando un file denominato kafka-dev.bicep, quindi aggiungere parametri con i valori predefiniti seguenti.

   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'
   

   Quando si distribuisce il modello bicep in qualsiasi fase, è possibile usare il az deployment group create comando .

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

   azd

   Definire le variabili iniziali.

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

   Usare i valori per inizializzare un modello minimo azd .

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

   Nota

   AZURE_ENV_NAME è diverso dal nome dell'ambiente dell'app contenitore. In questo contesto, AZURE_ENV_NAME in azd è per tutte le risorse in un modello. Queste risorse includono risorse non associate ad App contenitore. Si crea un nome diverso per l'ambiente App contenitore.

   Successivamente, creare infra/main.bicep e definire i parametri per un uso successivo.

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

2. Consente di accedere ad Azure.

   az login
   

3. Aggiornare l'interfaccia della riga di comando alla versione più recente.

   az upgrade
   

4. Aggiornare Bicep alla versione più recente.

   az bicep upgrade
   

5. Aggiungere l'estensione containerapp .

   az extension add --name containerapp --upgrade
   

6. Registrare gli spazi dei nomi necessari.

   az provider register --namespace Microsoft.App
   

   az provider register --namespace Microsoft.OperationalInsights
   

Creare un ambiente app contenitore

1. Crea un gruppo di risorse.

   Bash

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

   Bicep

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

   azd

   Non è necessaria alcuna configurazione speciale per la gestione dei gruppi di risorse in azd. Il azd comando ottiene il gruppo di risorse dal AZURE_ENV_NAME/--environment valore .

   È possibile testare il modello minimo con il up comando .

   azd up
   

   L'esecuzione di questo comando crea un gruppo di risorse vuoto.

2. Creare un ambiente app contenitore.

   Bash

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

   Bicep

   Aggiungere i valori seguenti al kafka-dev.bicep file.

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

   L'interfaccia della riga di comando di Azure crea automaticamente un'area di lavoro Log Analytics per ogni ambiente. Per generare un'area di lavoro usando un modello Bicep, dichiarare in modo esplicito l'ambiente e collegarlo al modello. Questo passaggio rende la distribuzione più stabile, anche se a costo di essere leggermente dettagliata.

   Aggiungere i valori seguenti all'ambiente.

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

   azd

   I modelli usati da azd usano i moduli bicep.

   Creare una cartella denominata ./infra/core/host, quindi creare un ./infra/core/host/container-apps-environment.bicep modulo con il contenuto seguente.

   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
   

   ./infra/main.bicep Nel file caricare il modulo usando i valori seguenti.

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

   Eseguire azd up per distribuire il modello.

Creare un servizio Apache Kafka

1. Creare un servizio Apache Kafka.

   Bash

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

   Bicep

   Aggiungere i valori seguenti 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'
   

   azd

   Creare un ./infra/core/host/container-app-service.bicep file di modulo con il contenuto seguente.

   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
   

   Aggiornare quindi il file del ./infra/main.bicep modulo con la dichiarazione seguente.

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

2. Distribuire il modello.

   Bash

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

   Bicep

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

   Suggerimento

   L'output kafkaLogs restituisce un comando dell'interfaccia della riga di comando per visualizzare i log di kafka al termine della distribuzione. È possibile eseguire il comando per visualizzare i log di inizializzazione del nuovo servizio Kafka.

   azd

   `azd up`
   

3. Visualizzare l'output del log dall'istanza kafka

   Bash

   Usare il logs comando per visualizzare i messaggi di log.

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

   Bicep

   L'esempio bicep precedente include l'output di un comando per visualizzare i log.

   Ad esempio:

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

   Se il comando non è disponibile, è possibile usare il nome del servizio per visualizzare i log usando l'interfaccia della riga di comando.

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

   azd

   Usare il logs comando per visualizzare i messaggi di log.

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

   

Creare un'app per testare il servizio

Quando si crea l'app, verrà configurata per usare ./kafka-topics.sh, ./kafka-console-producer.she kafka-console-consumer.sh per connettersi all'istanza di Kafka.

1. Creare un'app kafka-cli-app che si associa al servizio Kafka.

   Bash

   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"
   

   Bicep

   Aggiungere quanto segue ai valori 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'
   

   Suggerimento

   L'output kafkaCliExec restituisce un comando dell'interfaccia della riga di comando che è possibile eseguire per verificare che l'applicazione sia distribuita correttamente.

   azd

   Creare un modulo in ./infra/core/host/container-app.bicep e aggiungere i valori seguenti.

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

   Usare ora il modulo in ./infra/main.bicep aggiungendo i valori seguenti.

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

   Distribuire il modello con azd up.

   azd up
   

2. Eseguire il comando dell'interfaccia exec della riga di comando per connettersi all'app di test.

   Bash

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

   Bicep

   L'esempio bicep precedente include l'output che illustra come eseguire l'app.

   Ad esempio:

   [
     "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"
   ]
   

   Se il comando non è disponibile, è possibile usare il nome dell'app per eseguire l'applicazione usando il exec comando .

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

   azd

   az containerapp exec \
       --name kafka-cli-app \
       --resource-group $RESOURCE_GROUP \
       --command /bin/bash
   

   Quando si usa --bind o serviceBinds nell'app di test, le informazioni di connessione vengono inserite nell'ambiente dell'applicazione. Dopo aver eseguito la connessione al contenitore di test, è possibile esaminare i valori usando il env comando .

   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
   

3. Usare kafka-topics.sh per creare un argomento dell'evento.

   Creare un file 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
   

   Creare un quickstart-events argomento dell'evento.

   /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
   

4. Usare kafka-console-producer.sh per scrivere eventi nell'argomento.

   /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

   Il ./kafka-console-producer.sh comando richiede di scrivere eventi con >. Scrivere alcuni eventi come illustrato, quindi premere CTRL-C per uscire.

5. Usare kafka-console-consumer.sh per leggere gli eventi dall'argomento.

   /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
   

Uso di un servizio di sviluppo con un'app esistente

Se si dispone già di un'app che usa Apache Kafka, è possibile modificare la modalità di caricamento delle informazioni di connessione.

Creare prima di tutto le variabili di ambiente seguenti.

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

Usando l'interfaccia della riga di comando (o Bicep) è possibile aggiornare l'app da aggiungere --bind $KAFKA_SVC per usare il servizio di sviluppo.

Associazione al servizio di sviluppo

Distribuire kafka-ui per visualizzare e gestire l'istanza kafka.

Bash

Vedere Bicep o azd esempio.

Bicep

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

Il comando Bicep restituisce un URL. Copiare questo URL nel browser per visitare il sito distribuito.

azd

Eseguire l'aggiornamento ./infra/main.bicep con i valori seguenti.

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

Distribuire il modello con azd up.

azd up

Distribuire tutte le risorse

Usare gli esempi seguenti per distribuire tutte le risorse contemporaneamente.

Bicep

Il modello Bicep seguente contiene tutte le risorse di questa esercitazione.

È possibile creare un kafka-dev.bicep file con questo contenuto.

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'

Usare l'interfaccia della riga di comando di Azure per distribuirlo.

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 modello finale è disponibile in GitHub.

Usare azd up per distribuire il modello.

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

Pulire le risorse

Al termine, eseguire il comando seguente per eliminare il gruppo di risorse che contiene le risorse di App contenitore.

Attenzione

Il comando seguente elimina il gruppo di risorse specificato e tutte le risorse contenute al suo interno. Se nel gruppo di risorse specificato sono presenti anche risorse diverse da quelle usate in questa esercitazione, verranno eliminate.

az group delete \
    --resource-group $RESOURCE_GROUP