Migrating from AWS Elasticsearch to Elasticsearch Service on Elastic Cloud | Elastic Blog
Engineering

Migração do AWS Elasticsearch para o Elasticsearch Service na Elastic Cloud

Acesse todos os recursos do Elastic Stack

Sou um Arquiteto de Soluções, então sempre me perguntam como fazer para mover uma instalação Elastic do Amazon Elasticsearch Service (AWS ES) para o Elasticsearch Service.  Os usuários sempre fazem essa pergunta porque querem aproveitar todos os recursos, a experiência operacional e o suporte oferecido pela Elastic, que a Amazon não fornece. Este guia do especialista orientará você pelo processo de “lift-and-shift” na migração para o Elasticsearch Service da Elastic.

Você pode iniciar o uso do Elasticsearch Service com uma avaliação gratuita de 14 dias que permite criar uma instalação. Escolha o provedor da nuvem, AWS ou GCP, e a região onde você quer que a Elastic execute sua instalação.  Os usuários da AWS podem adicionar o Elasticsearch Service diretamente do AWS Marketplace, integrado na fatura da AWS.

Há muitos poucos recursos que excedem o que está disponível na distribuição open source, por exemplo Canvas, APM, aprendizado de máquina sem supervisão, índices congelados, SQL, segurança (além das políticas IAM básicas e somente no perímetro) e modelos de implantação que são exclusivos ao Elasticsearch Service na Elastic Cloud. A todo momento criamos mais recursos exclusivos. Para saber mais detalhes sobre o que estamos fazendo em relação ao AWS ES, visite nossa página de comparação do AWS Elasticsearch de vez em quando.

Migração do AWS Elasticsearch para o Elasticsearch Service na Elastic Cloud

Este guia de conteúdo técnico orienta na migração do AWS ES para o Elasticsearch Service na Elastic Cloud e exige alguma experiência em programação. Os clusters do AWS ES geralmente são provisionados em uma VPC, mas eles também podem ser posicionados em um endpoint público. Para manter este guia universal para ambos os cenários, usamos o Python AWS SDK. Você pode usar qualquer linguagem que tenha um AWS SDK (por exemplo, Java, Ruby, Go etc.), mas só damos exemplos no Python, abaixo.

Este guia tem duas partes:

Nota: se você já fez o snapshot manual do seu cluster do AWS ES para S3, passe diretamente para a parte dois.

Antes de começarmos, é importante entender algumas das etapas de segurança do IAM a seguir. Primeiro, para fazer o snapshot de um cluster do AWS ES para S3, o seu cluster do AWS ES precisa de permissão para gravar em um bucket S3 privado. Isso requer uma política e uma função IAM que tenham as permissões necessárias. Além disso, é preciso anexar uma política IAM a um usuário IAM (criando um, se necessário). O usuário IAM atua em nosso script conversando com o seu cluster do AWS ES e na sua instalação gerenciada pela Elastic lendo o snapshot do seu bucket S3.

Parte um – faça um snapshot para S3

A primeira parte deste guia aborda a configuração da função, da política e do usuário IAM para fazer o snapshot do seu cluster do AWS ES para S3. A documentação da AWS para esse processo pode ser encontrada aqui: Trabalhar com snapshots de índice do Amazon Elasticsearch Service. Essas informações podem servir como referência, caso você tenha dúvidas.

Você vai precisar anotar diversas variáveis que usaremos ao longo do processo. Copie e cole a tabela a seguir em um arquivo de anotações para consultar enquanto segue as orientações deste guia. Isso facilitará o preenchimento dos valores específicos de sua migração.

DescriçãoVariávelValor
ARN de domínio do AWS ES DOMAIN_ARN
URL do endpoint do AWS ES ES_ENDPOINT
Região do AWS ES ES_REGION
Nome do bucket do AWS S3 S3_BUCKET_NAME
Região do AWS S3 S3_REGION_NAME
ARN da função do AWS IAM ROLE_ARN
ID da chave de acesso do IAM da AWS ACCESS_KEY
Chave de acesso secreta do IAM da AWS SECRET_KEY
Repositório do snapshot do AWS ES SNAPSHOT_REPO my-snapshot-repo
Nome do snapshot do AWS ES SNAPSHOT_NAME my-snapshot

Você pode alterar os valores de SNAPSHOT_REPO e SNAPSHOT_NAME ou usar os exemplos fornecidos (ou seja, “my-snapshot-repo” e “my-snapshot”).

Passo 1 - obtenha as informações de seu AWS ES

Você precisará de algumas informações básicas sobre seu cluster AWS ES para fazer o snapshot dele para S3.

  1. No seu Console AWS, vá para o Elasticsearch Service
  2. Selecione o domínio do cluster do qual você quer fazer o snapshot
  3. Copie o valor de “Domain ARN” para seu arquivo de anotações (DOMAIN_ARN)
  4. Copie o valor da URL de “Endpoint” para seu arquivo de anotações (ES_ENDPOINT)
  5. Anote em qual região da AWS (por exemplo, us-east-1) seu cluster AWS ES está (ES_REGION)

Essas informações serão usadas abaixo na criação da política IAM e quando for a hora de emitir comandos para o cluster.

Passo 2 - crie um bucket AWS S3

Precisamos criar um bucket S3 para armazenar seu snapshot.

Importante: seu bucket S3 precisa estar na mesma região de seu cluster AWS ES. Você poderá fazer a restauração desse local para uma instalação gerenciada pela Elastic em qualquer região ou provedor da nuvem (AWS ou GCP).

  1. No seu Console AWS, vá para o serviço S3
  2. Crie um bucket S3 privado
    Nota: se você preservar os padrões, o seu bucket ficará privado e seguro
  3. Copie o nome do bucket para o seu arquivo de anotações (S3_BUCKET_NAME)
  4. Copie o nome da região do bucket para o seu arquivo de anotações (S3_REGION_NAME)

Essas informações são usadas quando registramos um repositório de snapshot com o Elasticsearch.

Passo 3 - crie uma função IAM

A seguir, criaremos uma função para delegar permissão ao Amazon Elasticsearch Service e assim fazer um snapshot no S3.

  1. No seu Console AWS, vá para o serviço IAM
  2. Selecione “Funções”
  3. Selecione “Criar função”
  4. Selecione “EC2” como o serviço que usará essa nova função (mais tarde mudaremos isso)
  5. Selecione “Próximo: Permissões”
  6. Deixe as políticas da função em branco por enquanto
  7. Selecione “Próximo: Tags”
  8. Selecione “Próximo: Revisar”
  9. Nome da função: TheSnapshotRole
  10. Selecione “Criar função”
  11. Na lista de funções, selecione a que você acabou de criar: TheSnapshotRole
  12. Selecione “Relações de confiança”
  13. Selecione “Editar relações de confiança”
  14. Copie e cole o seguinte no campo de relação de confiança (substituindo o que está lá)

    {
     "Version": "2012-10-17",
      "Statement": [{
        "Effect": "Allow",
        "Principal": {
          "Service": "es.amazonaws.com"
        },
        "Action": "sts:AssumeRole"
      }]
    }
    
  15. Selecione “Atualizar política de confiança”
  16. Selecione “Permissões”
  17. Selecione “Adicionar política em linha”
  18. Selecione a guia JSON
  19. Copie e cole o seguinte JSON (substituindo o que está lá)
  20. Substitua o S3_BUCKET_NAME pelo valor correto (em dois lugares)

    {
      "Version": "2012-10-17",
      "Statement": [{
          "Action": [
            "s3:ListBucket"
          ],
          "Effect": "Allow",
          "Resource": [
            "arn:aws:s3:::S3_BUCKET_NAME"
          ]
        },
        {
          "Action": [
            "s3:GetObject",
            "s3:PutObject",
            "s3:DeleteObject"
          ],
          "Effect": "Allow",
          "Resource": [
            "arn:aws:s3:::S3_BUCKET_NAME/*"
          ]
        }
      ]
    }   
  21. Selecione “Revisar política”
  22. Nome da política: TheSnapshotS3Policy
  23. Selecione “Criar política”
  24. Copie o valor de “Role ARN” para seu arquivo de anotações (ROLE_ARN)

Criamos então uma função IAM com uma política em linha que pode ler e gravar no seu bucket S3.

Passo 4 - crie uma política IAM

Precisamos criar uma nova política IAM com permissão para assumir a função acima e assim possibilitar o registro do repositório do snapshot.

  1. No seu Console AWS, vá para o serviço IAM
  2. Selecione “Políticas”
  3. Selecione “Criar política”
  4. Selecione a guia JSON
  5. Copie e cole o seguinte JSON (substituindo o que está lá)
  6. Substitua ROLE_ARN pelo valor correto
  7. Substitua DOMAIN_ARN pelo valor correto
  8. Substitua o S3_BUCKET_NAME pelo valor correto (em dois lugares)

    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Effect": "Allow",
          "Action": "iam:PassRole",
          "Resource": "ROLE_ARN"
        },
        {
          "Effect": "Allow",
          "Action": "es:ESHttpPut",
          "Resource": "DOMAIN_ARN/*"
        }
      ]
    }
    
  9. Selecione “Revisar política”
  10. Nome da política: TheSnapshotPolicy
  11. Selecione “Criar política”

Criamos então uma política IAM que permite à função IAM conversar com o seu domínio AWS ES.

Passo 5 - crie um usuário IAM

Se você não tem ainda um usuário IAM, precisaremos criar um e dar a ele acesso ao seu bucket S3 privado. Se você tem um usuário IAM, basta anexar a seguinte política IAM a ele.

  1. No seu Console AWS, vá para o serviço IAM
  2. Selecione “Usuários”
  3. Selecione “Adicionar usuário”
  4. Nome do usuário: TheSnapshotUser
  5. Marque a caixa “Acesso programático”
  6. Selecione “Próximo: Permissões”
  7. Selecione a caixa “Anexar políticas existentes de forma direta”
  8. Filtre as políticas digitando “TheSnapshot”
  9. Selecione a caixa ao lado da política “TheSnapshotPolicy”
  10. Selecione “Próximo: Tags”
  11. Selecione “Próximo: Revisar”
  12. Selecione “Criar usuário”
  13. Copie o valor de “ID da chave de acesso” para seu arquivo de anotações (ACCESS_KEY)
  14. Selecione “Exibir” em “Chave de acesso secreta”
  15. Copie o valor de “Chave de acesso secreta” para o seu arquivo de anotações (SECRET_KEY)
  16. Selecione “Fechar”
  17. Na lista de usuários, selecione o que você acabou de criar: TheSnapshotUser
  18. Selecione “Adicionar política em linha”
  19. Selecione a guia JSON
  20. Copie e cole o seguinte JSON (substituindo o que está lá)
  21. Substitua o S3_BUCKET_NAME pelo valor correto (em dois lugares)

    {
      "Version": "2012-10-17",
      "Statement": [{
          "Action": [
            "s3:ListBucket"
          ],
          "Effect": "Allow",
          "Resource": [
            "arn:aws:s3:::S3_BUCKET_NAME"
          ]
        },
        {
          "Action": [
            "s3:GetObject",
            "s3:PutObject",
            "s3:DeleteObject"
          ],
          "Effect": "Allow",
          "Resource": [
            "arn:aws:s3:::S3_BUCKET_NAME/*"
          ]
        }
      ]
    }
    
  22. Selecione “Revisar política”
  23. Nome da política: TheSnapshotUserS3Policy
  24. Selecione “Criar política”

Criamos então um usuário IAM que pode realizar um snapshot manual e fazer leituras nesse snapshot.

Passo 6 - configure o Python AWS SDK

Antes de executar um snapshot manual, precisamos registrar um repositório de snapshots na sua instalação. Para isso, é preciso enviar uma solicitação assinada para o seu cluster AWS ES. Uma das maneiras mais fáceis de fazer isso é usar o Python AWS SDK. Você pode usar outro AWS SDK (por exemplo, Java, Ruby, Go etc.) mas o exemplo abaixo usa o Python AWS SDK.

Instalaremos o Python AWS SDK usando o PIP do instalador do pacote do Python (pip3). O Python v3 precisa estar instalado. Caso você não tenha o Python v3 instalado, basta instalar o pip3 para obtê-lo. O gerenciador de pacotes do seu sistema operacional instalará o Python v3 automaticamente, já que o pip3 depende dele. Se tiver problemas nesse procedimento, consulte os documentos de instalação do Python.

Como instalar o pip3

Para instalar o pip3 no Red Hat and derivatives, use yum:

$ sudo yum -y install python3-pip

Como alternativa, algumas distribuições Fedora rotulam o pacote pip3 de maneira diferente:

$ sudo yum -y install python36-pip

Você pode fazer uma pesquisa se nenhum nome de pacote acima funcionar:

$ yum search pip

Em Debian derivatives such as Ubuntu, use apt-get:

$ sudo apt-get -y install python3-pip

Como instalar o Python AWS SDK

Depois que o pip3 for instalado, você pode instalar o Python AWS SDK chamado boto3:

$ pip3 install --user boto3 requests_aws4auth
Collecting boto3
...
Successfully installed boto3-1.9.106 requests-aws4auth-0.9 ...

Nota: Não será necessário acesso raiz se você especificar a flag --user.

Precisamos criar um diretório ~/.aws para conter nossas credentials AWS. Execute o seguinte comando para criar o diretório:

$ mkdir ~/.aws

Crie um arquivo chamado credentials usando seu editor favorito. Usaremos o nano para facilitar:

$ nano ~/.aws/credentials

Copie e cole o seguinte conteúdo no arquivo, substituindo as duas variáveis em letras maiúsculas.

[default]
aws_access_key_id = ACCESS_KEY
aws_secret_access_key = SECRET_KEY

Use Ctrl+x para sair do nano e siga as instruções para salvar o arquivo.

Em seguida, escreveremos alguns scripts do Python para executar as tarefas necessárias.

Passo 7 - realize um snapshot manual no AWS ES

Vamos realizar um teste rápido usando um script do Python para listar os índices do seu cluster do AWS ES. Dessa forma, asseguramos que suas credenciais da AWS estão funcionando e provamos que podemos conversar com o cluster.

Crie um arquivo chamado indices.py usando seu editor favorito. Usaremos o nano para facilitar:

$ nano indices.py

Copie e cole o seguinte conteúdo, substituindo as duas variáveis em letras maiúsculas pelos seus valores:

import boto3, requests
from requests_aws4auth import AWS4Auth
host = 'ES_ENDPOINT'
region = 'ES_REGION'
creds = boto3.Session().get_credentials()
auth = AWS4Auth(creds.access_key, creds.secret_key, region, 'es', session_token=creds.token)
print("Listing Indices from AWS ES ...")
req = requests.get(host + '/_cat/indices?v', auth=auth)
print("HTTP Response Code: " + str(req.status_code) + '\n' + req.text)

Use Ctrl+x para sair do nano e siga as instruções para salvar o arquivo.

Execute o script do Python.

$ python3 indices.py

Sua saída deve se parecer com o seguinte:

Listing Indices from AWS ES ...
HTTP Response Code: 200
health status index     uuid                   pri rep docs.count docs.deleted store.size pri.store.size
green  open   testindex yME2BphgR3Gt1ln6n03nHQ   5   1          1            0      4.4kb          4.4kb

Agora, crie um arquivo chamado register.py usando seu editor favorito.

$ nano register.py

Copie e cole o seguinte conteúdo, substituindo as sete variáveis em letras maiúsculas pelos seus valores:

import boto3, requests
from requests_aws4auth import AWS4Auth
host = 'ES_ENDPOINT'
region = 'ES_REGION'
repo_name = 'SNAPSHOT_REPO'
snapshot_name = 'SNAPSHOT_NAME'
s3_region_name = 'S3_REGION_NAME'
s3_bucket_name = 'S3_BUCKET_NAME'
role_arn = 'ROLE_ARN'
creds = boto3.Session().get_credentials()
auth = AWS4Auth(creds.access_key, creds.secret_key, region, 'es', session_token=creds.token)
headers = {"Content-Type": "application/json"}
payload = {
        "type": "s3",
        "settings": {
                "region": s3_region_name,
                "bucket": s3_bucket_name,
                "role_arn": role_arn
        }
}
print("Registering Snapshot with AWS ES ...")
url = host + '/_snapshot/' + repo_name
req = requests.put(url, auth=auth, json=payload, headers=headers)
print("HTTP Response Code: " + str(req.status_code) + '\n' + req.text)

Use Ctrl+x para sair do nano e siga as instruções para salvar o arquivo.

Execute o script do Python.

$ python3 register.py

Sua saída deve se parecer com o seguinte:

Registering Snapshot with AWS ES ...
HTTP Response Code: 200
{"acknowledged":true}

Em seguida, crie um arquivo chamado snapshot.py usando seu editor favorito.

$ nano snapshot.py

Copie e cole o seguinte conteúdo, substituindo as quatro variáveis em letras maiúsculas pelos seus valores:

import boto3, requests
from requests_aws4auth import AWS4Auth
host = 'ES_ENDPOINT'
region = 'ES_REGION'
repo_name = 'SNAPSHOT_REPO'
snapshot_name = 'SNAPSHOT_NAME'
creds = boto3.Session().get_credentials()
auth = AWS4Auth(creds.access_key, creds.secret_key, region, 'es', session_token=creds.token)
print("Starting Snapshot with AWS ES ...")
url = host + '/_snapshot/' + repo_name + '/' + snapshot_name
req = requests.put(url, auth=auth)
print("HTTP Response Code: " + str(req.status_code) + '\n' + req.text)

Use Ctrl+x para sair do nano e siga as instruções para salvar o arquivo.

Execute o script do Python.

$ python3 snapshot.py

Sua saída deve se parecer com o seguinte:

Starting Snapshot with AWS ES ...
HTTP Response Code: 200
{"accepted":true}

Nota: o tempo necessário para fazer um snapshot aumenta proporcionalmente ao tamanho do domínio AWS ES. De acordo com a documentação da AWS, as operações de snapshot de execução longa às vezes exibem a mensagem “504 GATEWAY_TIMEOUT”. A documentação diz que você pode ignorar esse erro e é só esperar a conclusão bem-sucedida do snapshot.

Por fim, vamos verificar o status do snapshot. Crie um arquivo chamado status.py.

$ nano status.py

Copie e cole o seguinte conteúdo, substituindo as quatro variáveis em letras maiúsculas pelos seus valores:

import boto3, requests
from requests_aws4auth import AWS4Auth
host = 'ES_ENDPOINT'
region = 'ES_REGION'
repo_name = 'SNAPSHOT_REPO'
snapshot_name = 'SNAPSHOT_NAME'
creds = boto3.Session().get_credentials()
auth = AWS4Auth(creds.access_key, creds.secret_key, region, 'es', session_token=creds.token)
print("Getting Status of Snapshot with AWS ES ...")
url = host + '/_snapshot/' + repo_name + '/' + snapshot_name + '?pretty'
req = requests.get(url, auth=auth)
print("HTTP Response Code: " + str(req.status_code) + '\n' + req.text)

Use Ctrl+x para sair do nano e siga as instruções para salvar o arquivo.

Execute o script do Python.

$ python3 status.py

Sua saída deve se parecer com o seguinte:

Getting Status of Snapshot with AWS ES ...
HTTP Response Code: 200
{
  "snapshots" : [ {
    "snapshot" : "my-snapshot",
    "uuid" : "ClYKt5g8QFO6r3kTCEzjqw",
    "version_id" : 6040299,
    "version" : "6.4.2",
    "indices" : [ "testindex" ],
    "include_global_state" : true,
    "state" : "SUCCESS",
    "start_time" : "2019-03-03T14:46:04.094Z",
    "start_time_in_millis" : 1551624364094,
    "end_time" : "2019-03-03T14:46:04.847Z",
    "end_time_in_millis" : 1551624364847,
    "duration_in_millis" : 753,
    "failures" : [ ],
    "shards" : {
      "total" : 5,
      "failed" : 0,
      "successful" : 5
    }
  } ]
}

A mensagem "state":"SUCCESS" indica que o snapshot para S3 foi realizado com sucesso e você está pronto para a parte dois!

Parte dois – faça uma restauração do S3

A segunda parte deste guia aborda a restauração de uma instalação gerenciada pela Elastic com base em um snapshot manual no S3.

Você pode provisionar uma instalação gerenciada pela Elastic em AWS ou GCP para esta parte do guia.

Passo 1 - dimensione sua instalação

A instalação que você criou no Elasticsearch Service do Elastic Cloud deve ter a mesma quantidade de recursos que o seu cluster AWS ES. Use os controles deslizantes e incremente o número de nós de dados para refletir o tamanho do cluster que você tem no AWS ES. Salve as alterações feitas antes de continuar.

Passo 2 - adicione um repositório personalizado

Na sua instalação gerenciada pela Elastic (não o seu cluster AWS ES), abra a Kibana e vá para “Dev Tools”.

Copie e cole a seguinte chamada de API em Dev Tools, substituindo as cinco variáveis:

PUT /_snapshot/SNAPSHOT_REPO
{
  "type": "s3",
  "settings": {
    "bucket": "S3_BUCKET_NAME",
    "region": "S3_REGION_NAME",
    "access_key": "ACCESS_KEY",
    "secret_key": "SECRET_KEY",
    "compress": true
  }
}

Execute a solicitação.

Você deve receber a seguinte resposta:

{
  "acknowledged": "true"
}

Você está quase lá.

Passo 3 - faça a restauração do S3

Finalmente é hora de realizar a restauração do repositório de snapshots que foi registrado há pouco.

Copie e cole a seguinte chamada de API em Dev Tools, substituindo as duas variáveis:

POST /_snapshot/SNAPSHOT_REPO/SNAPSHOT_NAME/_restore

Você deve receber a seguinte resposta:

{
  "accepted": "true"
}

Verifique o progresso da restauração com o seguinte:

GET /_snapshot/SNAPSHOT_REPO/SNAPSHOT_NAME/_status

A mensagem "state":"SUCCESS" indica que a restauração foi concluída com sucesso:

{
  "snapshots": [
    {
      "snapshot": "my-snapshot",
      "repository": "my-snapshot-repo",
      "state": "SUCCESS",
      ...
    }
  ]
}

Parabéns por ter concluído a migração “lift-and-shift” do AWS ES para o Elasticsearch Service.

Resumo

Agora que você está no Elasticsearch Service da Elastic Cloud, poderá aproveitar não só os recursos que não estão disponíveis no AWS ES, mas também a tranquilidade de saber que sua instalação está sob os cuidados dos especialistas que criaram o Elastic Stack. Além disso, terá a certeza de que, se houver algum problema em algum momento, os especialistas da equipe de suporte da Elastic estarão prontos para ajudar.  Caso você não esteja ainda aproveitando o Elasticsearch Service na Elastic Cloud, experimente a avaliação gratuita de 14 dias. Se tiver alguma dúvida, entre em contato.