Tutorial

Como criar um servidor Vault da Hashicorp usando o Packer e Terraform na DigitalOcean

Configuration ManagementTerraform

O autor selecionou o Free and Open Source Fund para receber uma doação como parte do programa Write for DOnations.

Introdução

O Vault, da Hashicorp, é uma ferramenta de código aberto usada para armazenar segredos e dados confidenciais de maneira segura em ambientes dinâmicos em nuvem. Ele fornece uma criptografia de dados forte, acesso baseado em identidade usando políticas personalizadas, leasing secreto e revogação, bem como um registro de auditoria detalhado que é registrado incessantemente. O Vault também possui uma API HTTP, tornando-o a escolha ideal para armazenar credenciais em implantações dispersas orientadas para o serviço, como o Kubernetes.

O Packer e o Terraform, também desenvolvidos pelo Hashicorp, podem ser usados juntos para criar e implantar imagens do Vault. Dentro desse fluxo de trabalho, os desenvolvedores podem usar o Packer para escrever imagens imutáveis para diferentes plataformas por meio de um único arquivo de configuração, que especifica o que a imagem deve conter. Então, o Terraform implanta quantas instâncias personalizadas das imagens criadas forem necessárias.

Neste tutorial, você usará o Packer para criar um snapshot imutável do sistema com o Vault instalado e orquestrar sua implantação usando o Terraform. No final, terá um sistema automatizado para implantar o Vault em funcionamento, permitindo que você se concentre em trabalhar com o Vault em si e não com o processo de instalação e fornecimento subjacentes.

Pré-requisitos

  • O Packer instalado em sua máquina local. Para instruções, visite a documentação oficial.
  • O Terraform instalado em sua máquina local. Visite a documentação oficial para um guia.
  • Um token de acesso pessoal (chave API) com permissões de leitura e escrita para sua conta DigitalOcean. Para aprender como criar uma chave API, visite Como criar um token de acesso pessoal nos docs.
  • Uma chave SSH que você usará para autenticar-se com os Droplets implantados pelo Vault, disponível em sua máquina local e adicionada em sua conta DigitalOcean. Você também precisará de suas digitais, que você pode copiar da página Security de sua conta assim que as tiver adicionado. Veja a documentação da DigitalOcean para instruções detalhadas ou o tutorial sobre Como configurar chaves SSH.

Passo 1 — Como criar um template do Packer

Nesta etapa, você escreverá um arquivo de configuração do Packer, chamado de template (modelo), que instruirá o Packer sobre como construir uma imagem que contém o Vault pré-instalado. Você escreverá a configuração no formato JSON, um formato de configuração legível comumente usado.

Para os fins deste tutorial, você armazenará todos os arquivos em ~/vault-orchestration. Crie o diretório executando o seguinte comando:

  • mkdir ~/vault-orchestration

Navegue até ele:

  • cd ~/vault-orchestration

Os arquivos de configuração para o Packer e Terraform serão armazenados separadamente, em diferentes sub-diretórios. Crie-os usando o seguinte comando:

  • mkdir packer terraform

Como trabalhará primeiro com o Packer, navegue até o respectivo diretório:

  • cd packer

Como usar variáveis do modelo

O controle de dados privados e de segredos de aplicativo em um arquivo separado de variáveis é a maneira ideal de mantê-los fora do seu modelo. Ao construir a imagem, o Packer substituirá as variáveis referenciadas pelos seus valores. Ter valores secretos codificados no seu modelo é um risco de segurança, especialmente se ele for compartilhado com membros da equipe ou colocado em sites públicos, como o GitHub.

Você os armazenará no subdiretório packer, em um arquivo chamado variables.json. Crie-o usando seu editor de texto favorito:

  • nano variables.json

Adicione as linhas a seguir:

~/vault-orchestration/packer/variables.json
{
    "do_token": "your_do_api_key",
    "base_system_image": "ubuntu-18-04-x64",
    "region": "nyc3",
    "size": "s-1vcpu-1gb"
}

O arquivo de variáveis consiste em um dicionário JSON, que mapeia nomes de variáveis aos seus valores. Você usará essas variáveis no modelo que está prestes a criar. Se quiser, é possível editar o tamanho de imagem base, região e do Droplet, de acordo com a documentação do desenvolvedor.

Lembre-se de substituir o your_do_api_key pela sua chave API que criou como parte dos pré-requisitos e, em seguida, salve e feche o arquivo.

Como criar compiladores e provisionadores

Com o arquivo de variáveis pronto, você agora criará o modelo do Packer em si.

Você armazenará o modelo do Packer para o Vault em um arquivo chamado template.json. Crie-o usando seu editor de texto:

  • nano template.json

Adicione as linhas a seguir:

~/vault-orchestration/packer/template.json
{
     "builders": [{
         "type": "digitalocean",
         "api_token": "{{user `do_token`}}",
         "image": "{{user `base_system_image`}}",
         "region": "{{user `region`}}",
         "size": "{{user `size`}}",
         "ssh_username": "root"
     }],
     "provisioners": [{
         "type": "shell",
         "inline": [
             "sleep 30",
             "sudo apt-get update",
             "sudo apt-get install unzip -y",
             "curl -L https://releases.hashicorp.com/vault/1.3.2/vault_1.3.2_linux_amd64.zip -o vault.zip",
             "unzip vault.zip",
             "sudo chown root:root vault",
             "mv vault /usr/local/bin/",
             "rm -f vault.zip"
         ]
    }]
}

No modelo, você define matrizes de construtores e de provisionadores. Os construtores dizem ao Packer como compilar a imagem do sistema (segundo seu tipo) onde armazená-la, enquanto os provisionadores contém conjuntos de ações que o Packer deve realizar no sistema antes de transformá-la em uma imagem imutável, como a instalação ou configuração de software. Sem qualquer provisionador, você acabaria com uma imagem do sistema base intocada. Tanto os construtores como os provisionadores exportam parâmetros para maior personalização de fluxos de trabalho.

Primeiro, você define um único construtor do tipo digitalocean, o que significa que quando ele for ordenado a compilar uma imagem, o Packer usará os parâmetros fornecidos para criar um Droplet temporário do tamanho definido usando a chave de API fornecida, com a imagem do sistema base e região especificadas. O formato para buscar uma variável é o {{user 'variable_name'}}, onde a parte destacada é seu nome.

Quando o Droplet temporário é provisionado, o provisionador se conectará a ele usando o SSH com o nome de usuário especificado e executará sequencialmente todos os provisionadores definidos antes da criação de um Snapshot da DigitalOcean por meio do Droplet e da exclusão desse Snapshot.

Ele é do tipo shell, que executará os comandos dados no destino. Os comandos podem ser especificados tanto como inline (em linha), como matrizes e strings, ou definidos em arquivos de script separados caso inseri-los no modelo torne-se algo complicado devido ao tamanho. Os comandos no modelo esperam 30 segundos para o sistema inicializar e então baixam e descompactam o Vault 1.3.2. Verifique a página oficial de download do Vault e substitua o link nos comandos por uma versão mais recente para o Linux, se estiver disponível.

Quando terminar, salve e feche o arquivo.

Para verificar a validade do seu modelo, execute o seguinte comando:

  • packer validate -var-file=variables.json template.json

O Packer aceita um caminho para o arquivo de variáveis por meio do argumento -var-file.

Você verá o seguinte resultado:

Output
Template validated successfully.

Se receber um erro, o Packer especificará exatamente onde ele ocorreu. Assim, será possível corrigi-lo.

Agora, você tem um modelo de trabalho que produz uma imagem com o Vault instalado, com sua chave de API e outros parâmetros definidos em um arquivo separado. Agora, tudo está pronto para invocar o Packer e compilar o snapshot.

Passo 2 — Como compilar o Snapshot

Nesta etapa, você compilará um Snapshot da DigitalOcean do seu modelo usando o comando build do Packer.

Para compilar seu snapshot, execute o seguinte comando:

  • packer build -var-file=variables.json template.json

Esse comando levará algum tempo para ser finalizado. Você verá um resultado extenso, que se parecerá com este:

Output
digitalocean: output will be in this color. ==> digitalocean: Creating temporary ssh key for droplet... ==> digitalocean: Creating droplet... ==> digitalocean: Waiting for droplet to become active... ==> digitalocean: Using ssh communicator to connect: ... ==> digitalocean: Waiting for SSH to become available... ==> digitalocean: Connected to SSH! ==> digitalocean: Provisioning with shell script: /tmp/packer-shell035430322 ... ==> digitalocean: % Total % Received % Xferd Average Speed Time Time Time Current ==> digitalocean: Dload Upload Total Spent Left Speed digitalocean: Archive: vault.zip ==> digitalocean: 100 45.5M 100 45.5M 0 0 154M 0 --:--:-- --:--:-- --:--:-- 153M digitalocean: inflating: vault ==> digitalocean: Gracefully shutting down droplet... ==> digitalocean: Creating snapshot: packer-1581537927 ==> digitalocean: Waiting for snapshot to complete... ==> digitalocean: Destroying droplet... ==> digitalocean: Deleting temporary ssh key... Build 'digitalocean' finished. ==> Builds finished. The artifacts of successful builds are: --> digitalocean: A snapshot was created: 'packer-1581537927' (ID: 58230938) in regions '...'

O Packer registra todas as etapas tomadas na construção do modelo. A última linha contém o nome do snapshot (como packer-1581537927) e seu ID entre parênteses, marcado em vermelho. Anote o ID do snapshot, pois você precisará dele no próximo passo.

Se o processo de compilação falhar devido a erros da API, espere alguns minutos e, em seguida, tente novamente.

Você criou um Snapshot da DigitalOcean, de acordo com seu modelo. O snapshot tem o Vault pré-instalado e agora é possível implantar Droplets com ele como a imagem do sistema deles. Na próxima etapa, será escrita a configuração do Terraform para automatizar tais implantações.

Passo 3 — Escrevendo a configuração do Terraform

Nesta etapa, será escrita a configuração do Terraform para automatizar implantações de Droplets do snapshot que contém o Vault que você acabou de compilar usando o Packer.

Antes de escrever de fato a configuração do Terraform para implantar o Vault do snapshot previamente compilado, será necessário primeiro configurar o provedor da DigitalOcean para ele. Navegue até o subdiretório terraform, executando:

  • cd ~/vault-orchestration/terraform

Então, crie um arquivo chamado do-provider.tf, onde você armazenará o provedor:

  • nano do-provider.tf

Adicione as linhas a seguir:

~/vault-orchestration/terraform/do-provider.tf
variable "do_token" {
}

variable "ssh_fingerprint" {
}

variable "instance_count" {
  default = "1"
}

variable "do_snapshot_id" {
}

variable "do_name" {
  default = "vault"
}

variable "do_region" {
}

variable "do_size" {
}

variable "do_private_networking" {
  default = true
}

provider "digitalocean" {
  token = var.do_token
}

Esse arquivo declara variáveis de parâmetro e fornece uma chave de API ao provedor digitalocean. Mais tarde, você usará essas variáveis em seu modelo do Terraform, mas será necessário primeiro especificar os valores delas. Por esse motivo, o Terraform é compatível com a especificação de valores de variáveis em um arquivo de definições de variáveis, de maneira semelhante ao Packer. O nome do arquivo deve terminar em .tfvars ou .tfvars.json. Mais tarde, você passará esse arquivo para o Terraform usando o argumento -var-file.

Salve e feche o arquivo.

Crie um arquivo de definições de variáveis chamado definitions.tfvars usando seu editor de texto:

  • nano definitions.tfvars

Adicione as linhas a seguir:

~/vault-orchestration/terraform/definitions.tf
do_token         = "your_do_api_key"
ssh_fingerprint  = "your_ssh_key_fingerprint"
do_snapshot_id   = your_do_snapshot_id
do_name          = "vault"
do_region        = "nyc3"
do_size          = "s-1vcpu-1gb"
instance_count   = 1

Lembre-se de substituir o your_do_api_key, your_ssh_key_fingerprint e your_do_snapshot_id pela chave de API da sua conta, a digital da sua chave SSH e pelo ID do snapshot que você anotou na etapa anterior, respectivamente. Os parâmetros do do_region e do_size devem ter os mesmos valores que no arquivo de variáveis do Packer. Se quiser implantar várias instâncias de uma vez, ajuste o instance_count para o valor desejado.

Quando terminar, salve e feche o arquivo.

Para obter mais informações sobre o provedor Terraform da DigitalOcean, visite os docs oficiais.

Você armazenará a configuração de implantação do snapshot do Vault em um arquivo chamado deployment.tf, dentro do diretório terraform. Crie-o usando seu editor de texto:

  • nano deployment.tf

Adicione as linhas a seguir:

~/vault-orchestration/terraform/deployment.tf
resource "digitalocean_droplet" "vault" {
  count              = var.instance_count
  image              = var.do_snapshot_id
  name               = var.do_name
  region             = var.do_region
  size               = var.do_size
  private_networking = var.do_private_networking
  ssh_keys = [
    var.ssh_fingerprint
  ]
}

output "instance_ip_addr" {
  value = {
    for instance in digitalocean_droplet.vault:
    instance.id => instance.ipv4_address
  }
  description = "The IP addresses of the deployed instances, paired with their IDs."
}

Aqui, você define um único recurso do tipo digitalocean_droplet chamado vault. Então, defina os parâmetros de acordo com os valores das variáveis e adicione uma chave SSH (usando sua digital) de sua conta DigitalOcean para o recurso do Droplet. Por fim, você transmite os endereços IP de todas as instâncias recém-implantadas para o console.

Salve e feche o arquivo.

Antes de fazer qualquer coisa com sua configuração de implantação, será necessário inicializar o diretório como um projeto Terraform:

  • terraform init

Você verá o seguinte resultado:

Output
Initializing the backend... Initializing provider plugins... The following providers do not have any version constraints in configuration, so the latest version was installed. To prevent automatic upgrades to new major versions that may contain breaking changes, it is recommended to add version = "..." constraints to the corresponding provider blocks in configuration, with the constraint strings suggested below. * provider.digitalocean: version = "~> 1.14" Terraform has been successfully initialized! You may now begin working with Terraform. Try running "terraform plan" to see any changes that are required for your infrastructure. All Terraform commands should now work. If you ever set or change modules or backend configuration for Terraform, rerun this command to reinitialize your working directory. If you forget, other commands will detect it and remind you to do so if necessary.

Ao inicializar um diretório como um projeto, o Terraform lê os arquivos de configuração disponíveis e baixa plug-ins considerados necessários, conforme registrado no resultado.

Agora, está pronta a configuração do Terraform para implantar seu snapshot do Vault. Agora, é possível seguir em frente para validá-lo e implantá-lo em um Droplet.

Passo 4 — Como implantar o Vault usando o Terraform

Nesta seção, você verificará sua configuração do Terraform usando o comando validate. Assim que for verificada com sucesso, você a aplicará e implantará um Droplet como resultado.

Execute o seguinte comando para testar a validade da sua configuração:

  • terraform validate

Você verá o seguinte resultado:

Output
Success! The configuration is valid.

Em seguida, execute o comando plan para ver o que o Terraform tentará fazer ao provisionar a infraestrutura de acordo com sua configuração:

  • terraform plan -var-file="definitions.tfvars"

O Terraform aceita um arquivo de definições de variáveis por meio do parâmetro -var-file.

O resultado será semelhante a:

Output
Refreshing Terraform state in-memory prior to plan... The refreshed state will be used to calculate this plan, but will not be persisted to local or remote state storage. ------------------------------------------------------------------------ An execution plan has been generated and is shown below. Resource actions are indicated with the following symbols: + create Terraform will perform the following actions: # digitalocean_droplet.vault[0] will be created + resource "digitalocean_droplet" "vault" { ... } Plan: 1 to add, 0 to change, 0 to destroy. ------------------------------------------------------------------------ Note: You didn't specify an "-out" parameter to save this plan, so Terraform can't guarantee that exactly these actions will be performed if "terraform apply" is subsequently run.

O + verde no início da linha resource "digitalocean_droplet" "vault" significa que o Terraform criará um novo Droplet chamado vault, usando os parâmetros que seguem. Isso está correto. Portanto, execute agora o plano pelo comando terraform apply:

  • terraform apply -var-file="definitions.tfvars"

Digite yes quando solicitado. Após alguns minutos, o Droplet terminará o provisionamento e você verá um resultado semelhante a este:

Output
An execution plan has been generated and is shown below. Resource actions are indicated with the following symbols: + create Terraform will perform the following actions: + digitalocean_droplet.vault-droplet ... Plan: 1 to add, 0 to change, 0 to destroy. ... digitalocean_droplet.vault-droplet: Creating... ... Apply complete! Resources: 1 added, 0 changed, 0 destroyed. Outputs: instance_ip_addr = { "181254240" = "your_new_server_ip" }

No resultado, o Terraform registra as ações que ele realizou (neste caso, para criar um Droplet) e mostra o endereço IP público dele no final. Você o usará para se conectar ao seu novo Droplet na próxima etapa.

Você criou um novo Droplet do snapshot que contém o Vault e agora tudo está pronto para verificá-lo.

Passo 5 — Como verificar seu Droplet implantado

Nesta etapa, você acessará seu novo Droplet usando o SSH e verificará se o Vault foi instalado corretamente.

Se estiver no Windows, utilize softwares como o Kitty ou Putty para se conectar ao Droplet com uma chave SSH.

Em máquinas Linux e macOS, utilize o comando ssh já disponível para se conectar:

  • ssh root@your_server_ip

Digite yes quando solicitado. Assim que estiver logado, rode o Vault executando:

  • vault

Você verá o resultado “ajuda”, que se parece com este:

Output
Usage: vault <command> [args] Common commands: read Read data and retrieves secrets write Write data, configuration, and secrets delete Delete secrets and configuration list List data or secrets login Authenticate locally agent Start a Vault agent server Start a Vault server status Print seal and HA status unwrap Unwrap a wrapped secret Other commands: audit Interact with audit devices auth Interact with auth methods debug Runs the debug command kv Interact with Vault's Key-Value storage lease Interact with leases namespace Interact with namespaces operator Perform operator-specific tasks path-help Retrieve API help for paths plugin Interact with Vault plugins and catalog policy Interact with policies print Prints runtime configurations secrets Interact with secrets engines ssh Initiate an SSH session token Interact with tokens

Finalize a conexão digitando exit.

Agora, você verificou que seu Droplet recém-implantado foi criado do snapshot que você fez e que o Vault está instalado corretamente.

Conclusão

Agora, você tem um sistema automatizado para implantar o Vault da Hashicorp em Droplets da DigitalOcean usando o Terraform e o Packer. Agora, é possível implantar quantos servidores Vault você quiser. Para começar a usar o Vault, será necessário inicializá-lo e configurá-lo ainda mais. Para instruções sobre como fazer isso, visite os docs oficiais.

Para outros tutoriais usando o Terraform, confira nossa página de conteúdo do Terraform.

Creative Commons License