Tutorial: Erstellen und Verwenden eines Apache Kafka-Diensts für die Entwicklung

Mit Azure Container Apps können Sie eine Verbindung mit Entwicklungs- und Produktionsdiensten herstellen, um eine Vielzahl von Funktionen für Ihre Anwendungen bereitzustellen.

In diesem Tutorial erfahren Sie, wie Sie einen Apache Kafka-Entwicklungsdienst erstellen und verwenden.

Dieses Tutorial enthält Azure CLI-Befehle und Bicep-Vorlagenfragmente. Wenn Sie Bicep verwenden, können Sie alle Fragmente einer einzelnen Bicep-Datei hinzufügen und die Vorlage auf einmal bereitstellen.

• Erstellen einer Container Apps-Umgebung zur Bereitstellung Ihrer Dienste und Container-Apps
• Erstellen eines Apache Kafka-Clusters
• Einrichten einer Befehlszeilen-App für die Verwendung des Apache Kafka-Entwicklungsdiensts
• Bereitstellen einer kafka-ui-App zum Anzeigen von Anwendungsdaten
• Kompilieren einer endgültigen Bicep-Vorlage zum Bereitstellen aller Ressourcen mithilfe einer konsistenten und vorhersagbaren Vorlagenbereitstellung
• Verwenden einer azd-Vorlage für eine Bereitstellung aller Ressourcen mit einem Befehl

Voraussetzungen

• Installieren Sie die Azure CLI.
• Optional: Azure Developer CLI für die folgenden AZD-Anweisungen

Hinweis

Für eine Bereitstellung mit einem Befehl springen Sie direkt zum letzten azd-Vorlagenschritt.

Einrichten

1. Definieren Sie Variablen für gemeinsame Werte.

   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

   Mit den folgenden Variablen können Sie die CLI verwenden, um die Bicep-Vorlage bereitzustellen.

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

   Für Bicep erstellen Sie zunächst eine Datei namens kafka-dev.bicep und fügen dann Parameter mit den folgenden Standardwerten hinzu.

   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'
   

   Da Sie die Bicep-Vorlage in jeder Phase einsetzen, können Sie den Befehl az deployment group create verwenden.

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

   azd

   Definieren Sie Ihre Anfangsvariablen.

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

   Verwenden Sie die Werte, um eine minimale azd-Vorlage zu initialisieren.

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

   Hinweis

   AZURE_ENV_NAME unterscheidet sich vom Namen der Container-App-Umgebung. In diesem Zusammenhang steht AZURE_ENV_NAME in azd für alle Ressourcen in einer Vorlage. Dazu gehören auch Ressourcen, die nicht mit Container Apps verbunden sind. Sie erstellen einen anderen Namen für die Container Apps-Umgebung.

   Als Nächstes erstellen Sie infra/main.bicep und definieren Sie Parameter für die spätere Verwendung.

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

2. Melden Sie sich bei Azure an.

   az login
   

3. Führen Sie für die CLI ein Upgrade auf die aktuelle Version durch.

   az upgrade
   

4. Aktualisieren Sie Bicep auf die aktuelle Version.

   az bicep upgrade
   

5. Fügen Sie die Erweiterung containerapp hinzu.

   az extension add --name containerapp --upgrade
   

6. Registrieren Sie die erforderlichen Namespaces.

   az provider register --namespace Microsoft.App
   

   az provider register --namespace Microsoft.OperationalInsights
   

Erstellen einer Container-Apps-Umgebung

1. Erstellen Sie eine Ressourcengruppe.

   Bash

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

   Bicep

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

   azd

   Für die Verwaltung von Ressourcengruppen in azd ist kein spezielles Setup erforderlich. Der Befehl azd ruft die Ressourcengruppe aus dem Wert AZURE_ENV_NAME/--environment ab.

   Sie können die minimale Vorlage jedoch mit Befehl up testen.

   azd up
   

   Durch Ausführen dieses Befehls wird eine leere Ressourcengruppe erstellt.

2. Erstellen Sie eine Container Apps-Umgebung.

   Bash

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

   Bicep

   Fügen Sie der Datei kafka-dev.bicep die folgenden Werte hinzu.

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

   Die Azure CLI erstellt automatisch einen Log Analytics-Arbeitsbereich für jede Umgebung. Um einen Arbeitsbereich mithilfe einer Bicep-Vorlage zu generieren, deklarieren Sie die Umgebung explizit und verknüpfen sie in der Vorlage. Dieser Schritt macht Ihre Bereitstellung stabiler, auch wenn er ein wenig umständlich ist.

   Fügen Sie Ihrer Umgebung die folgenden Werte hinzu.

   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

   Die von azd verwendeten Vorlagen verwenden Bicep-Module.

   Erstellen Sie einen Ordner mit dem Namen ./infra/core/host und erstellen Sie dann ein ./infra/core/host/container-apps-environment.bicep-Modul mit dem folgenden Inhalt.

   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
   

   Laden Sie das Modul in der ./infra/main.bicep-Datei mit den folgenden Werten.

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

   Führen Sie azd up aus, um die Vorlage bereitzustellen.

Erstellen eines Apache Kafka-Clusters

1. Erstellen Sie einen Apache Kafka-Dienst.

   Bash

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

   Bicep

   Fügen Sie kafka-dev.bicep die folgenden Werte hinzu.

   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

   Erstellen Sie die Moduldatei ./infra/core/host/container-app-service.bicep mit folgendem Inhalt.

   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
   

   Aktualisieren Sie dann die Moduldatei ./infra/main.bicep mit der folgenden Deklaration.

   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. Stellen Sie die Vorlage bereit.

   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
   

   Tipp

   Die Ausgabe kafkaLogs gibt einen CLI-Befehl aus, mit dem Sie die Protokolle von Kafka nach Abschluss der Bereitstellung anzeigen können. Sie können den Befehl ausführen, um die Initialisierungsprotokolle des neuen Kafka-Diensts anzuzeigen.

   azd

   `azd up`
   

3. Anzeigen der Protokollausgabe aus der Kafka-Instanz

   Bash

   Verwenden Sie den Befehl logs, um Protokollnachrichten anzuzeigen.

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

   Bicep

   Das vorherige Bicep-Beispiel enthält die Ausgabe eines Befehls zum Anzeigen der Protokolle.

   Beispiel:

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

   Wenn der Befehl nicht verfügbar ist, können Sie den Dienstnamen verwenden, um die Protokolle über die CLI abzurufen.

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

   azd

   Verwenden Sie den Befehl logs, um Protokollnachrichten anzuzeigen.

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

   

Erstellen einer App zum Testen des Diensts

Wenn Sie die App erstellen, legen Sie sie so fest, dass ./kafka-topics.sh, ./kafka-console-producer.sh und kafka-console-consumer.sh zum Herstellen der Verbindung mit der Kafka-Instanz verwendet werden.

1. Erstellen Sie eine kafka-cli-app-App, die an den Kafka-Dienst gebunden ist.

   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

   Fügen Sie kafka-dev.bicep die folgenden Werte hinzu.

   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'
   

   Tipp

   Die Ausgabe kafkaCliExec gibt einen CLI-Befehl aus, den Sie ausführen können, um zu überprüfen, ob die Anwendung ordnungsgemäß bereitgestellt wurde.

   azd

   Erstellen Sie unter ./infra/core/host/container-app.bicep ein Modul, und fügen Sie die folgenden Werte hinzu.

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

   Verwenden Sie nun das Modul in ./infra/main.bicep, indem Sie die folgenden Werte hinzufügen.

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

   Stellen Sie die Vorlage mithilfe von azd up bereit.

   azd up
   

2. Führen Sie den CLI-Befehl exec zum Herstellen einer Verbindung mit der Testanwendung aus.

   Bash

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

   Bicep

   Das vorherige Bicep-Beispiel enthält eine Ausgabe, die zeigt, wie Sie die App ausführen.

   Beispiel:

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

   Wenn Sie den Befehl nicht haben, können Sie den Anwendungsnamen verwenden, um die Anwendung mit dem Befehl exec auszuführen.

   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
   

   Wenn Sie in der Test-App --bind oder serviceBinds verwenden, werden die Verbindungsinformationen in die Anwendungsumgebung eingefügt. Nachdem Sie eine Verbindung mit dem Testcontainer hergestellt haben, können Sie die Werte mithilfe des Befehls env untersuchen.

   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. Verwenden Sie kafka-topics.sh, um ein Ereignisthema zu erstellen.

   Erstellen Sie die Datei 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
   

   Erstellen Sie ein quickstart-events-Ereignisthema.

   /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. Verwenden Sie kafka-console-producer.sh zum Schreiben von Ereignissen in das Thema.

   /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
   

   Hinweis

   Der Befehl ./kafka-console-producer.sh fordert Sie auf, Ereignisse mit > zu schreiben. Schreiben Sie einige Ereignisse wie gezeigt, und drücken Sie dann zum Beenden CTRL-C.

5. Verwenden Sie kafka-console-consumer.sh zum Lesen von Ereignissen aus dem Thema.

   /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
   

Verwenden eines Entwicklungsdienstes bei einer vorhandenen Anwendung

Wenn Sie bereits über eine App verfügen, die Apache Kafka verwendet, können Sie ändern, wie Verbindungsinformationen geladen werden.

Legen Sie zunächst die folgenden Umgebungsvariablen fest.

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

Anschließend können Sie die Anwendung mithilfe der CLI (oder Bicep) aktualisieren, um --bind $KAFKA_SVC hinzuzufügen, um den erstellten Entwicklungsdienst zu verwenden.

Herstellen einer Bindung mit dem Entwicklungsdienst

Stellen Sie kafka-ui bereit, um die Kafka-Instanz anzuzeigen und zu verwalten.

Bash

Weitere Informationen finden Sie unter „Bicep“ oder im azd-Beispiel.

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

Der Bicep-Befehl gibt eine URL zurück. Kopieren Sie diese URL in Ihren Browser, um die bereitgestellte Website zu besuchen.

azd

Aktualisieren Sie ./infra/main.bicep mit den folgenden Werten.

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

Stellen Sie die Vorlage mithilfe von azd up bereit.

azd up

Bereitstellen aller Ressourcen

Verwenden Sie die folgenden Beispiele, wenn Sie alle Ressourcen gleichzeitig bereitstellen möchten.

Bicep

Die folgende Bicep-Vorlage enthält alle Ressourcen für dieses Tutorial.

Erstellen Sie eine Datei kafka-dev.bicep mit dem folgenden Inhalt.

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'

Verwenden Sie die Azure CLI, um die Vorlage bereitzustellen.

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

Eine finale Vorlage finden Sie auf GitHub.

Verwenden Sie azd up zum Bereitstellen der Vorlage.

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

Bereinigen von Ressourcen

Führen Sie anschließend den folgenden Befehl aus, um die Ressourcengruppe zu löschen, die Ihre Container Apps-Ressourcen enthält.

Achtung

Mit dem folgenden Befehl werden die angegebene Ressourcengruppe und alle darin enthaltenen Ressourcen gelöscht. Falls in der angegebenen Ressourcengruppe Ressourcen enthalten sind, die nicht zum Umfang dieses Tutorials gehören, werden sie ebenfalls gelöscht.

az group delete \
    --resource-group $RESOURCE_GROUP