Como implantar o Elasticsearch no GCP GKE Autopilot

Neste artigo, vamos aprender como implantar o Elasticsearch no Google Cloud Kubernetes (GKE) usando o Autopilot.

Para o Elasticsearch, usaremos Elastic Cloud on Kubernetes (ECK), que é o operador oficial do Elasticsearch para Kubernetes e simplifica a orquestração de implantações do Kubernetes de todos os componentes do Elastic Stack.

Para saber mais sobre como implantar clusters do Elasticsearch em diferentes infraestruturas do GCP, você pode ler nossos artigos de introdução ao Google Cloud Compute e Google Cloud Marketplace.

Esforço de implantação do Elasticsearch

O que é o GKE Autopilot?

O Google Kubernetes Engine (GKE) Autopilot oferece uma experiência Kubernetes totalmente gerenciada, na qual o Google cuida da configuração do cluster, do gerenciamento de nós, da segurança e do redimensionamento, enquanto os desenvolvedores se concentram na implantação de aplicativos, permitindo que as equipes passem do código à produção em minutos com as práticas recomendadas integradas.

Quando usar o ECK no Google Cloud?

O Elastic Cloud on Kubernetes (ECK) é mais indicado para organizações com infraestrutura Kubernetes existente que desejam implantar o Elasticsearch com recursos avançados, como funções dedicadas para nós, alta disponibilidade e automação.

Como configurar o ECK na Google Cloud?

1. Faça login no Google Cloud Console.

2. No canto superior direito , clique no botão Cloud Shell para acessar o console e implantar o cluster GKE a partir daí. Alternativamente, você pode usar o gcloud CLI.

Lembre-se de atualizar o id do projeto com o seu durante o tutorial.

3. Ative a Google Kubernetes Engine API.

Clique em Avançar.

Agora, a API do Kubernetes Engine deve aparecer como habilitada ao pesquisar pela API do Kubernetes Engine.

4. No Cloud Shell, crie um cluster Autopilot. Vamos chamá-lo de autopilot-cluster-1 e também substituir autopilot-test pelo id do seu projeto.

gcloud beta container --project "autopilot-test-457216" clusters create-auto "autopilot-cluster-1" --region "us-central1" --release-channel "regular" --tier "standard" --enable-ip-access --no-enable-google-cloud-access --network "projects/autopilot-test-457216/global/networks/default" --subnetwork "projects/autopilot-test-457216/regions/us-central1/subnetworks/default" --cluster-ipv4-cidr "/17" --binauthz-evaluation-mode=DISABLED

5. Espere até que esteja pronto. Leva cerca de 10 minutos para ser criado.

Uma mensagem de confirmação será exibida após a configuração correta do cluster.

6. Configure o acesso na linha de comando do kubectl.

gcloud container clusters get-credentials autopilot-cluster-1 --region us-central1 --project autopilot-test-457216

Você deverá ver:

Entrada kubeconfig gerada para autopilot-cluster-1.

7. Instale o operador Elastic Cloud on Kubernetes (ECK).

# Install ECK Custom Resource Definitions
kubectl create -f https://download.elastic.co/downloads/eck/2.16.1/crds.yaml

# Install the ECK operator
kubectl apply -f https://download.elastic.co/downloads/eck/2.16.1/operator.yaml

8. Vamos criar um nó único do Elasticsearch com os valores padrão.

Se quiser conferir algumas receitas de diferentes instalações, você pode visitar este link.

Lembre-se de que, se você não especificar um storageClass, o ECK usará o definido por padrão, que para o GKE é standard-rwo, que usa o driver CSI de disco persistente do Compute Engine, e criará um volume de 1 GB com ele.

cat <<EOF | kubectl apply -f -
apiVersion: elasticsearch.k8s.elastic.co/v1
kind: Elasticsearch
metadata:
  name: quickstart
spec:
  version: 9.0.0
  nodeSets:
  - name: default
    count: 1
    config:
      node.store.allow_mmap: false
EOF

Desativamos nmap porque a máquina padrão do GKE tem um valor de vm.max_map_count muito baixo. Desabilitá-lo não é recomendado para produção, mas aumenta o valor da vm.max_map_count. Você pode ler mais sobre como fazer isso aqui.

9. Vamos também implantar um cluster Kibana de nó único. Para o Kibana, vamos adicionar um LoadBalancer que nos dará um IP externo que podemos usar para acessar o Kibana a partir do nosso dispositivo.

cat <<EOF | kubectl apply -f -
apiVersion: kibana.k8s.elastic.co/v1
kind: Kibana
metadata:
  name: quickstart
spec:
  version: 9.0.0
  http:
    service:
      metadata:
        annotations:
          cloud.google.com/l4-rbs: "enabled"
      spec:
        type: LoadBalancer
  count: 1
  elasticsearchRef:
    name: quickstart
EOF

Observe a anotação:

cloud.google.com/l4-rbs: "enabled"

É muito importante porque diz ao Autopilot que forneça um LoadBalancer voltado para o público. Se não estiver ativado, o LoadBalancer será interno.

10. Verifique se seus pods estão funcionando.

kubectl get pods

11. Você também pode run kubectl get elasticsearch e kubectl get kibana para obter estatísticas mais específicas, como versão, nós e integridade do Elasticsearch.

12. Acesse seus serviços.

kubectl get svc

Isso mostrará o URL externo do Kibana em EXTERNAL-IP. Pode levar alguns minutos para a provisão do LoadBalancer. Copie o valor de EXTERNAL-IP.

13 Obtenha a senha do Elasticsearch para o usuário 'elastic':

kubectl get secret quickstart-es-elastic-user -o=jsonpath='{.data.elastic}' | base64 --decode

14. Acesse o Kibana por meio do seu navegador:

• URL: https://<EXTERNAL_IP>:5601

• Username:elastic

• Senha: 28Pao50lr2GpyguX470L2uj5 (do passo anterior)

15. Acessando a partir do seu navegador, você verá a tela de boas-vindas.

Se você quiser alterar as especificações do cluster do Elasticsearch, como mudar ou redimensionar nós, pode aplicar o manifesto yml novamente com as novas configurações:

cat <<EOF | kubectl apply -f -
apiVersion: elasticsearch.k8s.elastic.co/v1
kind: Elasticsearch
metadata:
  name: quickstart
spec:
  version: 9.0.0
  nodeSets:
    - name: default
      count: 2
      config:
        node.store.allow_mmap: false
      podTemplate:
        spec:
          containers:
            - name: elasticsearch
              resources:
                requests:
                  memory: 1.5Gi
                  cpu: 2
                limits:
                  memory: 1.5Gi
                  cpu: 2
EOF

Neste exemplo, adicionaremos mais um nó e modificaremos a RAM e a CPU. Como você pode ver, agora kubectl get elasticsearch mostra 2 nós:

O mesmo vale para Kibana:

cat <<EOF | kubectl apply -f -
apiVersion: kibana.k8s.elastic.co/v1
kind: Kibana
metadata:
  name: quickstart
spec:
  version: 9.0.0
  http:
    service:
      metadata:
        annotations:
          cloud.google.com/l4-rbs: "enabled"
      spec:
        type: LoadBalancer
  count: 1
  elasticsearchRef:
    name: quickstart
  podTemplate:
    spec:
      containers:
        - name: kibana
          env:
            - name: NODE_OPTIONS
              value: "--max-old-space-size=1024"
          resources:
            requests:
              memory: 0.5Gi
              cpu: 0.5
            limits:
              memory: 1Gi
              cpu: 1
EOF

Podemos ajustar o CPU/RAM do container e também o uso de memória do Node.js (max-old-space-size).

Lembre-se de que as reivindicações de volume existentes não podem ser reduzidas. Após aplicar a atualização, o operador fará as alterações com o menor tempo de interrupção.

Lembre-se de excluir o cluster quando terminar os testes para evitar custos desnecessários.

gcloud container clusters delete autopilot-cluster-1

Próximas etapas

Se você quiser saber mais sobre o Kubernetes e o Google Kubernetes Engine, consulte estes artigos:

• Elastic Cloud on Kubernetes | Elastic Docs

• Apresentando o GKE Autopilot | Blog do Google Cloud

• Visão geral do Autopilot | Google Kubernetes Engine (GKE)