Roteie eventos de nuvem para Webhooks com Grade de Eventos do Azure no Kubernetes

Artigo
03/17/2023

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

Importante

A Grade de Eventos no Kubernetes com Azure Arc está atualmente em versão prévia pública. Essa versão prévia é fornecida sem um contrato de nível de serviço e não é recomendada para cargas de trabalho de produção. Alguns recursos podem não ter suporte ou podem ter restrição de recursos. Para obter mais informações, consulte Termos de Uso Complementares de Versões Prévias do Microsoft Azure.

Pré-requisitos

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

Criar uma localização personalizada

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

Declare as seguintes variáveis para manter os valores do cluster do Azure Arc, grupo de recursos e nomes de localização 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>"
```
Obter a ID do recurso do cluster do Azure Arc conectado. Atualize os valores para o nome do cluster do 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)    
```
Obter a ID do recurso de extensão da Grade de Eventos. Esta etapa presume que o nome que você deu para a extensão da Grade de Eventos é eventgrid-ext. Atualize o cluster do Azure Arc e os nomes 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 o local personalizado e os nomes do grupo de recursos 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 de recurso referente ao 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, confira Criar e gerenciar locais personalizados no Azure Arc habilitado para o Kubernetes.

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 do 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 comando a seguir 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, confira az eventgrid topic create.

Criar um ponto de extremidade de mensagem

Antes de criar uma assinatura para o tópico personalizado, crie um ponto de extremidade para a mensagem de evento. Normalmente, o ponto de extremidade executa ações com base nos dados de evento. Para simplificar esse início rápido, implante um aplicativo web predefinido que exiba as mensagens do evento. A solução implantada inclui um plano do Serviço de Aplicativo, um aplicativo Web do Aplicativo do Serviço de e o código-fonte do GitHub.

Na página do artigo, selecione Implantar no Azure para implantar a solução na sua assinatura. No portal do Azure, forneça os valores para os parâmetros.
A implantação pode levar alguns minutos para ser concluída. Depois que a implantação for bem-sucedida, exiba seu aplicativo Web para garantir que ele esteja em execução. Em um navegador da Web, navegue até: https://<your-site-name>.azurewebsites.net

Se a implantação falhar, verifique a mensagem de erro. Talvez o nome do site já esteja em uso. Implante o modelo novamente e escolha outro nome para o site.
Você verá o site, mas nenhum evento ainda estará publicado.

Criar uma assinatura

Os assinantes podem se registrar para eventos publicados em um tópico. Para receber qualquer evento, você precisa criar uma assinatura do Grade de Eventos em 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 com suporte, confira 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 comando a seguir.

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, confira 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 exemplos de eventos neste ponto de extremidade do 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. Ela é a chave primária do tópico. Para obter essa chave do portal do Azure, alterne para a guia Chaves de acesso da página Tópico da Grade de Eventos. Para postar um evento em um tópico personalizado, você precisará da chave de acesso.
```
az eventgrid topic key list --name $topicname -g $resourcegroupname --query "key1" --output tsv
```
Execute o seguinte comando Curl para publicar o evento. Especifique a URL e a chave do ponto de extremidade das 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 da Grade de Eventos é ClusterIP, você poderá executar Curl a partir 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 configuração a seguir. Você pode ajustar o dnsPolicy de acordo com suas necessidades. Para obter mais informações, confira 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 do shell a partir do contêiner
```
    kubectl exec --stdin --tty test-pod -- /bin/bash
```
Neste ponto, você tem uma sessão do 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.
Observação

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

Verifique se no Visualizador de Grade de Eventos

Você disparou o evento, e a Grade de Eventos enviou a mensagem para o ponto de extremidade configurado durante a assinatura. Exiba seu aplicativo Web para ver o evento que você acabou de enviar.

Exibir evento recebido no Visualizador de Grade de Eventos

Próximas etapas

Veja os artigos a seguir:

Manipuladores de eventos e destinos – fornece informações sobre todos os manipuladores de eventos e destinos para os quais a Grade de Eventos no Kubernetes dá suporte.
Filtragem de eventos – fornece informações sobre a filtragem de eventos em assinaturas de evento.

Compartilhar via