Encaminhar eventos na nuvem para Webhooks com a Grade de Eventos do Azure no Kubernetes

Artigo
03/10/2024

Neste início rápido, você cria um tópico na Grade de Eventos no Kubernetes, cria uma assinatura para o tópico e envia um evento de exemplo para o tópico para testar o cenário.

Importante

A Grade de Eventos no Kubernetes com o Azure Arc está atualmente em visualização pública. Esta versão de pré-visualização é disponibiliza sem um contrato de nível de serviço e não é recomendada para cargas de trabalho de produção. Algumas funcionalidades poderão não ser suportadas ou poderão ter capacidades limitadas. Para obter mais informações, veja Termos Suplementares de Utilização para Pré-visualizações do Microsoft Azure.

Pré-requisitos

Conecte seu cluster Kubernetes ao Azure Arc.
Instale a extensão Event Grid no cluster do Kubernetes. Essa extensão implanta a Grade de Eventos em um cluster do Kubernetes.

Criar um local personalizado

Como uma extensão de local do Azure, um local personalizado permite que você use seu cluster Kubernetes habilitado para Arco do Azure como um local de destino para implantar recursos, como tópicos de Grade de Eventos. Um local personalizado representa um namespace no cluster e é o local onde os tópicos e assinaturas de eventos são implantados. Nesta seção, você cria um local personalizado.

Declare as variáveis a seguir para armazenar valores do cluster do Azure Arc, grupo de recursos e nomes de locais personalizados. Copie essas instruções para um editor, substitua os valores e copie/cole na janela bash.
```
resourcegroupname="<AZURE RESOURCE GROUP NAME>"
arcclustername="<AZURE ARC CLUSTER NAME>"
customlocationname="<CUSTOM LOCATION NAME>"
```
Obtenha a ID do recurso do cluster conectado ao Azure Arc. Atualize os valores para o nome do cluster Azure Arc e os parâmetros do grupo de recursos antes de executar o comando.
```
hostresourceid=$(az connectedk8s show -n $arcclustername -g $resourcegroupname --query id -o tsv)    
```
Obtenha o ID do recurso de extensão da Grade de Eventos. Esta etapa pressupõe que o nome que você deu para a extensão de grade de eventos é eventgrid-ext. Atualize os nomes do cluster do Azure Arc e do grupo de recursos antes de executar o comando.
```
clusterextensionid=$(az k8s-extension show --name eventgrid-ext --cluster-type connectedClusters -c $arcclustername -g $resourcegroupname  --query id -o tsv)    
```

Crie um local personalizado usando os dois valores da etapa anterior. Atualize os nomes de locais e grupos de recursos personalizados antes de executar o comando.

az customlocation create -n $customlocationname -g $resourcegroupname --namespace arc --host-resource-id $hostresourceid --cluster-extension-ids $clusterextensionid

Obtenha a ID do recurso do local personalizado. Atualize o nome do local personalizado antes de executar o comando.
```
customlocationid=$(az customlocation show -n $customlocationname -g $resourcegroupname --query id -o tsv)    
```
Para obter mais informações sobre como criar locais personalizados, consulte Criar e gerenciar locais personalizados no Kubernetes habilitado para Azure Arc.

Criar um tópico

Nesta seção, você cria um tópico no local personalizado criado na etapa anterior. Atualize os nomes dos tópicos do grupo de recursos e da Grade de Eventos antes de executar o comando. Atualize o local se você estiver usando um local diferente do Leste dos EUA.

Declare uma variável para manter o nome do tópico.
```
topicname="<TOPIC NAME>"
```

Execute o seguinte comando para criar um tópico.

az eventgrid topic create -g $resourcegroupname --name $topicname --kind azurearc --extended-location-name $customlocationid --extended-location-type customlocation --input-schema CloudEventSchemaV1_0 --location $region

Para obter mais informações sobre o comando CLI, consulte az eventgrid topic create.

Criar um ponto final de mensagem

Antes de criar uma assinatura para o tópico personalizado, crie um ponto de extremidade para a mensagem do evento. Normalmente, o ponto final executa as ações com base nos dados do evento. Para simplificar esse início rápido, implante um aplicativo Web pré-criado que exibe as mensagens do evento. A solução implementada inclui um plano do Serviço de Aplicações, uma aplicação Web do Serviço de Aplicações e o código de origem do GitHub.

Na página do artigo, selecione Implantar no Azure para implantar a solução em sua assinatura. No portal do Azure, indique os valores para os parâmetros.
A implementação pode demorar alguns minutos. Após a implementação ter sido concluída com êxito, verifique a aplicação Web para verificar se está em execução. Num browser, navegue para: https://<your-site-name>.azurewebsites.net

Se a implantação falhar, verifique a mensagem de erro. Pode ser porque o nome do site já está tomado. Implante o modelo novamente e escolha um nome diferente para o site.
Vê o site, mas ainda não foram publicados eventos no mesmo.

Criar uma subscrição

Os subscritores podem inscrever-se em eventos publicados sobre um tema. Para receber qualquer evento, você precisa criar uma assinatura da Grade de Eventos para um tópico de interesse. Uma assinatura de evento define o destino para o qual esses eventos são enviados. Para saber mais sobre todos os destinos ou manipuladores suportados, consulte Manipuladores de eventos.

Para criar uma assinatura de evento com um destino WebHook (ponto de extremidade HTTPS), insira um nome para a assinatura do evento, atualize o nome do site e execute o seguinte comando.

topicid=$(az eventgrid topic show --name $topicname --resource-group $resourcegroupname --query id -o tsv)
az eventgrid event-subscription create --name <EVENT SUBSCRIPTION NAME> --source-resource-id $topicid --endpoint https://<SITE NAME>.azurewebsites.net/api/updates

Para obter mais informações sobre o comando CLI, consulte az eventgrid event-subscription create.

Enviar eventos para o tópico

Execute o seguinte comando para obter o ponto de extremidade para o tópico: Depois de copiar e colar o comando, atualize o nome do tópico e o nome do grupo de recursos antes de executar o comando. Você publica eventos de exemplo para este ponto de extremidade de tópico.
```
az eventgrid topic show --name $topicname -g $resourcegroupname --query "endpoint" --output tsv
```
Execute o seguinte comando para obter a chave para o tópico personalizado: Depois de copiar e colar o comando, atualize o nome do tópico e o nome do grupo de recursos antes de executar o comando. É a chave principal do tópico. Para obter essa chave do portal do Azure, alterne para a guia Teclas de acesso da página Tópico da Grade de Eventos . Para poder postar um evento em um tópico personalizado, você precisa da chave de acesso.
```
az eventgrid topic key list --name $topicname -g $resourcegroupname --query "key1" --output tsv
```
Execute o seguinte comando Curl para postar o evento. Especifique a URL e a chave do ponto de extremidade nas etapas 1 e 2 antes de executar o comando.
```
curl  -k -X POST -H "Content-Type: application/cloudevents-batch+json" -H "aeg-sas-key: <KEY_FROM_STEP_2>" -g <ENDPOINT_URL_FROM_STEP_1> \
-d  '[{ 
      "specversion": "1.0",
      "type" : "orderCreated",
      "source": "myCompanyName/us/webCommerceChannel/myOnlineCommerceSiteBrandName",
      "id" : "eventId-n",
      "time" : "2020-12-25T20:54:07+00:00",
      "subject" : "account/acct-123224/order/o-123456",
      "dataSchema" : "1.0",
      "data" : {
         "orderId" : "123",
         "orderType" : "PO",
         "reference" : "https://www.myCompanyName.com/orders/123"
      }
}]'
```
Se a URL do ponto de extremidade do tópico da etapa 1 for um endereço IP privado, como no caso em que o tipo de serviço do agente de Grade de Eventos for ClusterIP, você poderá executar Curl de dentro de outro pod no cluster para ter acesso a esse endereço IP. Por exemplo, você pode executar as seguintes etapas:
1. Crie um arquivo de manifesto com a seguinte configuração. Você pode querer ajustar o dnsPolicy de acordo com suas necessidades. Para obter mais informações, consulte DNS para serviços e pods.
```
apiVersion: v1
kind: Pod
metadata:
    name: test-pod2
spec:
    containers:
      - name: nginx
        image: nginx
    hostNetwork: true
    dnsPolicy: ClusterFirstWithHostNet       
```
2. Crie o pod.
```
    kubectl apply -f <name_of_your_yaml_manifest_file>
```
3. Verifique se o pod está em execução.
```
    kubectl get pod test-pod
```
4. Iniciar uma sessão de shell a partir do contêiner
```
    kubectl exec --stdin --tty test-pod -- /bin/bash
```
Neste ponto, você tem uma sessão de shell de um contêiner em execução no cluster a partir do qual você pode executar o comando Curl descrito em uma etapa anterior.
Nota

Para saber como enviar eventos na nuvem usando linguagens de programação, consulte os seguintes exemplos:
- C#.
- Java
- JavaScript e TypeScript
- Python

Verificar no Visualizador de Grade de Eventos

Acionou o evento e o Event Grid enviou a mensagem para o ponto final que configurou ao subscrever. Verifique a aplicação Web para ver o evento que acabámos de enviar.

View received event in Event Grid Viewer

Próximos passos

Consulte os seguintes artigos:

Manipuladores de eventos e destinos - fornece informações sobre todos os manipuladores de eventos e destinos suportados pela Grade de Eventos no Kubernetes.
Filtragem de eventos - fornece informações sobre a filtragem de eventos em assinaturas de eventos.