Esta página foi traduzida pela API Cloud Translation.

Migrar do Pub/Sub Lite para o serviço gerenciado do Google Cloud para Apache Kafka

Este documento detalha como migrar dados de um tópico do Pub/Sub Lite para um tópico do Serviço gerenciado para Apache Kafka.

Antes de começar

Ative a API Google Kubernetes Engine.
Identifique um tópico do Pub/Sub Lite para migrar. Escolha um nome para o tópico do Google Cloud Managed Service para Apache Kafka. Determine também para qual Serviço gerenciado para o cluster do Apache Kafka você está migrando.

Fluxo de trabalho de migração

Para migrar seus dados, conclua as seguintes tarefas. Os detalhes específicos mais adiante nesta página.

Crie uma conta de serviço do Google Kubernetes Engine.
Criar um cluster do Google Kubernetes Engine.
personalizar uma imagem do Docker com a configuração; detalhes dos seus tópicos.
Implantar a imagem do Docker em um cluster do Google Kubernetes Engine.

Dentro da imagem, Kafka Connect e o plug-in do Pub/Sub Lite para Kafka Connect são usados para assinar uma nova assinatura do Pub/Sub Lite. publicar no serviço gerenciado do Apache Kafka.

Criar uma conta de serviço do Google Kubernetes Engine

Nesta seção, descrevemos como criar uma conta de serviço do IAM que as permissões necessárias para executar um cluster do Google Kubernetes Engine.

No console do Google Cloud, crie uma nova conta de serviço do IAM com as permissões mínimas necessárias para operar o Google Kubernetes Engine.
Conceda os outros papéis do IAM a seguir à conta de serviço. Esses facilitam o processo de migração.
- Função de cliente do Kafka gerenciado (roles/managedkafka.client)
- Papel de Assinante do Pub/Sub Lite (roles/pubsublite.subscriber)
- Papel de leitor do Pub/Sub Lite (roles/pubsublite.Viewer)
- Papel de leitor do Artifact Registry (roles/artifactregistry.reader)

Criar um cluster do GKE

Nesta seção, descrevemos como criar um cluster do GKE que usa o serviço conta criada na etapa anterior.

Acesse a página Google Kubernetes Engine no console do Google Cloud.

Acessar o Google Kubernetes Engine
Clique em Criar.

A página Criar um cluster do Autopilot é exibida.
Na guia Configurações avançadas, altere a conta de serviço para o IAM conta de serviço que você criou na etapa anterior.
Opcionalmente, defina outras configurações conforme necessário.
Para criar o cluster, clique em Criar.

crie uma imagem do Docker do Kafka Connect

Esta seção descreve como criar e personalizar uma imagem Docker do Kafka Connect para seu tópico.

Clone o repositório do GitHub de migração do Pub/Sub Lite.
Para a conta de serviço do IAM que você criou anteriormente, gere uma chave de conta JSON.

Use uma ferramenta base64 para codificar a chave JSON. Por exemplo,

Linux
```
base64 -w 0 < my_service_account.json > password.txt
```
Mac
```
base64 < account_key_json > password.txt
```

Nos arquivos secretos da repositório do GitHub, atualize os seguintes arquivos com as informações para vincular o repositório ao seu projeto do Google Cloud, Pub/Sub Lite e Kafka.

.gcp/gmk_sasl_service_account → sensitive
<service-account-name>@<gcp-project>.iam.gserviceaccount.com

.gcp/gmk_sasl_service_account_key → sensitive
<base64 encoded sasl service account key>

.gcp/kafka_ssl_truststore_location → sensitive
<full path of the ssl truststore jks file location>

.gcp/kafka_ssl_truststore_password → sensitive
<password for the ssl truststore jks>

.gcp/gmk_bootstrap_servers → environment specific
bootstrap.<google-managed-kafka-cluster-name>.<google-managed-kafka-cluster-region name>.managedkafka.<google-managed-cluster-host-project-name>.cloud.goog:9092

.gcp/kafka_connect_group_id → environment specific
<Kafka Connect group id (unique per worker group) for the Kafka connect workers in distributed mode>

.gcp/kafka_config_storage_topic → environment specific
<Kafka topic name used by Kafka Connect for tracking the config>

.gcp/kafka_offset_storage_topic → environment specific
<Kafka topic name used by Kafka Connect for tracking the offsets>

.gcp/kafka_status_storage_topic → environment specific
<Kafka topic name used by Kafka Connect for tracking the status>

.gcp/kafka_sink_topic → environment specific
<target sink Kafka topic name used by Kafka Connect for migrating the data from the Pub/Sub Lite topic>

.gcp/pubsub_lite_gcp_project → environment specific
<Google Cloud project that hosts the Pub/Sub Lite source subscription to be used for migrating the Pub/Sub Lite topic to sink the Kafka topic>

.gcp/pubsub_lite_gcp_location → environment specific
<Google Cloud location for the Pub/Sub Lite source subscription tor migrate the Pub/Sub Lite topic to sink Kafka topic>

.gcp/pubsub_lite_subscription → environment specific
<Pub/Sub Lite source subscription name to be used for migrating the pubsub lite topic to Kafka topic>

Crie a imagem do Docker executando o arquivo docker/build-image.sh.
```
./push-image.sh
```
Atualize a imagem docker/push-image.sh com o nome do projeto do Google Cloud.
Envie a imagem para o Artifact Registry executando o docker/push-image.sh .
```
./push-image.sh
```

Implante uma carga de trabalho do Kafka Connect

Esta seção descreve como implantar a imagem Docker do Kafka Connect em um cluster do Google Kubernetes Engine.

Instalar e configurar kubectl com o plug-in de autenticação.
Gere o kubeconfig para seu cluster do Google Kubernetes Engine.

Criar e conceder uma conta de serviço do Google Kubernetes Engine com as permissões corretas para representar sua conta do IAM.

$KSA_NAME = KUBERNETES_SERVICE_ACCOUNT_NAME
$PROJECT_ID = GOOGLE_CLOUD_PROJECT_ID
$IAM_SA_NAME = IAM_SERVICE_ACCOUNT_NAME

kubectl create serviceaccount $KSA_NAME \
    --namespace=default

gcloud iam service-accounts add-iam-policy-binding \
$IAM_SA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:$PROJECT_ID.svc.id.goog[default/$KSA_NAME]"

kubectl annotate serviceaccount $KSA_NAME \
    --namespace default \
iam.gke.io/gcp-service-account=$IAM_SA_NAME@$PROJECT_ID.iam.gserviceaccount.com

Abra o arquivo K8s.yaml em um editor de texto e atualize os valores a seguir.
1. Substitua <workflow_name> pelo nome do fluxo de trabalho do Kafka Connect.
2. Substitua <gke_service_account> pela conta de serviço do Google Kubernetes Engine. nome.
Execute o arquivo K8s.yaml.
```
kubectl create -f k8s.yaml
```
Isso cria uma carga de trabalho do Kafka Connect em execução no seu Google Kubernetes Engine cluster do Kubernetes e inicia o conector do Pub/Sub Lite para mover os dados do seu Tópico do Pub/Sub Lite para o Google Cloud Managed Service para Apache Kafka.

Monitorar um job

Quando um job está em execução, é possível inspecioná-lo conectando-se ao Kafka Connect endpoint REST.

No console do Google Cloud, acesse Detalhes da implantação > Página "Carga de trabalho".
Clique na implantação do Kubernetes.

A página de detalhes da implantação é aberta.
Em Como expor serviços, clique em Expor e adicione a porta 8083.

Ative o encaminhamento de portas.

O link padrão que você recebe ao configurar o encaminhamento de portas retorna uma saída semelhante a esta:

{"version":"3.4.0","commit":"2e1947d240607d53","kafka_cluster_id":"6H6qWA0dQnuK31hBPqYUDg"}

Se você anexar /connectors ao link, ele listará o conector em execução, Por exemplo:

["PubSubLiteSourceConnector"]

Por exemplo, verificar este link url:8083/connectors/PubSubLiteSourceConnector/status gera uma lista de tarefas e o status delas.

{"name":"PubSubLiteSourceConnector","connector":{"state":"RUNNING","worker_id":"10.53.0.157:8083"},"tasks":[{"id":0,"state":"RUNNING","worker_id":"10.53.0.139:8083"},{"id":1,"state":"RUNNING","worker_id":"10.53.0.157:8083"},{"id":2,"state":"RUNNING","worker_id":"10.53.0.139:8083"},{"id":3,"state":"RUNNING","worker_id":"10.53.0.157:8083"},{"id":4,"state":"RUNNING","worker_id":"10.53.0.157:8083"},{"id":5,"state":"RUNNING","worker_id":"10.53.0.139:8083"},{"id":6,"state":"RUNNING","worker_id":"10.53.0.139:8083"},{"id":7,"state":"RUNNING","worker_id":"10.53.0.157:8083"},{"id":8,"state":"RUNNING","worker_id":"10.53.0.139:8083"},{"id":9,"state":"RUNNING","worker_id":"10.53.0.157:8083"}],"type":"source"}

Migração por etapas

Depois que o tópico do Pub/Sub Lite for migrado para o Kafka, será possível migrar seus assinantes e editores. Para fazer isso, siga estas etapas.

Migre assinantes. Atualize seus inscritos para consumir tópicos do Kafka em vez de tópicos do Pub/Sub Lite.

Isso deve ser feito gradualmente em um ambiente de desenvolvimento controlado.

O ideal é manter dois conjuntos de assinantes para verificar se mensagens idênticas são recebidos do Kafka e do Pub/Sub Lite. Depois que o comportamento correto for verificado, desative seu Pub/Sub Lite assinantes.
Migrar editores. Atualizar os editores para que publiquem diretamente em tópicos do Kafka em vez de tópicos do Pub/Sub Lite.

Semelhante à migração de assinantes, isso deve ser feito de forma gradual um ambiente de desenvolvimento controlado. Se os dados duplicados não forem um problema, pode manter dois conjuntos de editores para verificar o comportamento. Após a verificação o comportamento, desative os editores do Pub/Sub Lite.
Depois que todos os assinantes e editores forem migrados, desative a a ferramenta de migração excluindo a carga de trabalho e o cluster.
Exclua o tópico original do Pub/Sub Lite.

A seguir

Saiba mais sobre o serviço gerenciado para Apache Kafka.