One place for hosting & domains

      Vault

      Cómo crear un servidor de Hashicorp Vault con Packer y Terraform en DigitalOcean [Inicio rápido]


      Introducción

      Vault, de Hashicorp, es una herramienta de código abierto que permite almacenar de forma segura datos secretos y sensibles en entornos dinámicos en la nube. Packer y Terraform, también desarrollados por Hashicorp, pueden usarse juntos para crear e implementar imágenes de Vault.

      En este tutorial, usará Packer para crear una instantánea inmutable del sistema con Vault instalado y orquestará su implementación usando Terraform.

      Para acceder a una versión más detallada de este tutorial, consulte Cómo crear un servidor de Vault de Hashicorp usando Packer y Terraform en DigitalOcean.

      Requisitos previos

      • Packer instalado en su máquina local. Para acceder a instrucciones, consulte la documentación oficial.
      • Terraform instalado en su computadora local. Consulte la documentación oficial para obtener ayuda.
      • Un token de acceso personal (clave de API) con permisos de lectura y escritura para su cuenta de DigitalOcean. Consulte Cómo crear un token de acceso personal para crear uno.
      • Una clave SSH que usará para la autenticación con los Droplets de Vault implementados, disponible en su equipo local y añadida a su cuenta de DigitalOcean. También necesitará su huella; podrá copiarla de la página Seguridad de su cuenta una vez que la haya añadido. Consulte la documentación de DigitalOcean para hallar instrucciones detalladas o el tutorial Cómo configurar claves SSH.

      Paso 1: Crear una plantilla de Packer

      Cree el directorio ~/vault-orchestration y posiciónese en él para almacenar sus archivos de Vault:

      • mkdir ~/vault-orchestration
      • cd ~/vault-orchestration

      Cree directorios separados para la configuración de Packer y Terraform ejecutando lo siguiente:

      Diríjase al directorio de Packer:

      Usar variables de plantilla

      Cree variables.json en el subdirectorio packer para almacenar sus datos de variables privadas:

      Añada las siguientes líneas:

      ~/vault-orchestration/packer/variables.json

      {
        "do_token": "your_do_api_key",
        "base_system_image": "ubuntu-18-04-x64",
        "region": "nyc3",
        "size": "s-1vcpu-1gb"
      }
      

      Usará estas variables en la plantilla que está a punto de crear. Puede editar los valores básicos de imagen, región y tamaño de Droplet conforme a los documentos para desarrolladores.

      Sustituya your_do_api_key por su clave de API y, luego, guarde y cierre el archivo.

      Crear compiladores y aprovisionadores

      Cree su plantilla de Packer para Vault en un archivo llamado template.json:

      Añada las siguientes líneas:

      ~/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"
             ]
      }]
      }
      

      Definirá un solo generador digitalocean. Packer creará un Droplet temporal con el tamaño, la imagen y la región definidos usando la clave API proporcionada.

      El proveedor establecerá conexión con él usando SSH con el nombre de usuario especificado y ejecutará todos los proveedores definidos antes de crear una instantánea de DigitalOcean del Droplet y eliminarlo.

      Es del tipo shell, que ejecutará los comando determinados en el destino. Los comandos de la plantilla esperarán 30 segundos para que el sistema arranque, y luego descargarán y desempaquetarán Vault 1.3.2. Consulte la página oficial de descarga de Vault para acceder a la versión más reciente para Linux.

      Guarde y cierre el archivo.

      Verifique la validez de su plantilla:

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

      Verá el siguiente resultado:

      Output

      Template validated successfully.

      Paso 2: Crear la instantánea

      Cree su instantánea con el comando build de Packer:

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

      Verá muchos resultados que tendrán un aspecto similar a 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 '...'

      La última línea contiene el nombre de la instantánea (como packer-1581537927) y su ID entre paréntesis, resaltados aquí. Tome nota del ID de la instantánea, ya que lo necesitará en el siguiente paso.

      Si el proceso de creación falla debido a errores de API, espere unos minutos y realice un nuevo intento.

      Paso 3: Escribir la configuración de Terraform

      Diríjase al subdirectorio terraform:

      • cd ~/vault-orchestration/terraform

      Cree un archivo llamado do-provider.tf para almacenar el proveedor:

      Añada las siguientes líneas:

      ~/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
      }
      

      Este archivo proporciona una clave de API al proveedor digitalocean. Para especificar los valores de estas variables, creará un archivo de definiciones de variables similar a Packer. El nombre del archivo debe terminar en .tfvars o .tfvars.jason.

      Guarde y cierre el archivo.

      Cree un archivo de definiciones de variables:

      Añada las siguientes líneas:

      ~/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
      

      Sustituya your_do_api_key, your_ssh_key_fingerprint y your_do_snapshot_id, (el ID de la instantánea del que tomó nota en el paso anterior). ​​ Los parámetros do_region y do_size deben tener los mismos valores que en el archivo de variables de Packer.

      Guarde y cierre el archivo.

      Cree el siguiente archivo para almacenar la configuración de la implementación de la instantánea de Vault:

      Añada las siguientes líneas:

      ~/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."
      }
      

      Defina un único recurso del tipo digitalocean_droplet llamado vault. Establezca sus parámetros según los valores de las variables y añada una clave SSH (usando su huella) de su cuenta de DigitalOcean al recurso del Droplet. Use output para mostrar las direcciones IP de todas las instancias recientemente implementadas en la consola.

      Guarde y cierre el archivo.

      Inicie el directorio como proyecto de Terraform:

      Verá el siguiente 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.

      Paso 4: Implementar Vault usando Terraform

      Pruebe la validez de la configuración:

      Verá el siguiente resultado:

      Output

      Success! The configuration is valid.

      Ejecute el comando plan para ver qué intentará hacer Terraform respecto del aprovisionamiento de la infraestructura:

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

      El resultado será similar a este:

      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.

      Ejecute el plan:

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

      El Droplet finalizará el aprovisionamiento y verá un resultado similar 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" }

      Paso 5: Verificar su Droplet implementado

      Ejecute lo siguiente para establecer conexión con su nuevo Droplet:

      Una vez que inicie sesión, ejecute Vault con lo siguiente:

      Verá su resultado de “ayuda”:

      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

      Conclusión

      Ahora dispone de un sistema automatizado para implementar Hashicorp Vault en Droplets de DigitalOcean usando Terraform y Packer. Para comenzar a usar Vault, deberá iniciarlo y realizar algunas configuraciones adicionales. Para hallar instrucciones sobre cómo hacerlo, consulte la documentación oficial.

      Para hallar más tutoriales sobre Terraform, consulte nuestra página de contenido de Terraform.



      Source link

      Como construir um servidor Vault da Hashicorp usando o Packer e o Terraform na DigitalOcean [Início rápido]


      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. O Packer e o Terraform, também desenvolvidos pelo Hashicorp, podem ser usados juntos para criar e implantar imagens do Vault.

      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.

      Para obter uma versão mais detalhada deste tutorial, consulte Como construir um servidor Vault da Hashicorp usando o Packer e o Terraform na DigitalOcean.

      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. Visite Como criar um token de acesso pessoal para criar um.
      • 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

      Crie e mova-se para o diretório ~/ ~/vault-orchestration para armazenar seus arquivos do Vault:

      • mkdir ~/vault-orchestration
      • cd ~/vault-orchestration

      Crie diretórios separados para a configuração do Packer e do Terraform, executando:

      Navegue até o diretório do Packer:

      Como usar variáveis do modelo

      Crie um variables.json em seu subdiretório packer para armazenar dados de sua variável privada:

      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"
      }
      

      Você usará essas variáveis no modelo que está prestes a criar. É possível editar o tamanho de imagem base, região e do Droplet, de acordo com a documentação do desenvolvedor.

      Substitua your_do_api_key pela sua chave API e, em seguida, salve e feche o arquivo.

      Como criar compiladores e provisionadores

      Crie seu modelo do Packer para o Vault em um arquivo chamado 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"
             ]
      }]
      }
      

      Você define um único construtor digitalocean. O Packer criará um Droplet temporário do tamanho, imagem e região definidos usando a chave de API fornecida.

      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 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 para a versão mais atual do Linux.

      Salve e feche o arquivo.

      Verifique a validade do seu modelo:

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

      Você verá o seguinte resultado:

      Output

      Template validated successfully.

      Passo 2 — Como compilar o Snapshot

      Compile seu snapshot com o comando build do Packer:

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

      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 '...'

      A última linha contém o nome do snapshot (como packer-1581537927) e o ID dele entre parênteses, destacada aqui. Anote seu ID do snapshot, pois 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.

      Etapa 3 — Escrevendo a configuração do Terraform

      Navegue até o subdiretório terraform:

      • cd ~/vault-orchestration/terraform

      Crie um arquivo chamado do-provider.tf para armazenar o provedor:

      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
      }
      

      Este arquivo fornece uma chave de API ao provedor da digitalocean. Para especificar os valores dessas variáveis, você criará um arquivo de definições de variáveis, de maneira similar ao do Packer. O nome do arquivo deve terminar em .tfvars ou .tfvars.json.

      Salve e feche o arquivo.

      Crie um arquivo de definições de variáveis:

      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
      

      Substitua your_do_api_key, your_ssh_key_fingerprint e your_do_snapshot_id (o ID do snapshot que você anotou no passo anterior). Os parâmetros do do_region e do_size devem ter os mesmos valores que no arquivo de variáveis do Packer.

      Salve e feche o arquivo.

      Crie o seguinte arquivo para armazenar a configuração de implantação do snapshot do Vault:

      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."
      }
      

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

      Salve e feche o arquivo.

      Inicialize o diretório como um projeto Terraform:

      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.

      Passo 4 — Como implantar o Vault usando o Terraform

      Teste a validade da configuração:

      Você verá o seguinte resultado:

      Output

      Success! The configuration is valid.

      Execute o comando plan para ver o que o Terraform tentará fazer em relação ao provisionamento da infraestrutura:

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

      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.

      Execute o plano:

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

      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" }

      Passo 5 — Como verificar seu Droplet implantado

      Para se conectar ao seu novo Droplet, execute o seguinte:

      Assim que estiver logado, execute o Vault com:

      Você verá o resultado “ajuda”:

      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

      Conclusão

      Agora, você tem um sistema automatizado para implantar o Vault da Hashicorp em Droplets da DigitalOcean usando o Terraform e o Packer. 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.



      Source link

      Cómo crear un Vault Server de Hashicorp usando Packer y Terraform en DigitalOcean


      El autor seleccionó la Free and Open Source Fund para recibir una donación como parte del programa Write for DOnations.

      Introducción

      Vault, de Hashicorp, es una herramienta de código abierto que permite almacenar de forma segura datos secretos y sensibles en entornos dinámicos en la nube. Ofrece un cifrado de datos seguro, acceso basado en identidad usando políticas personalizadas, y arrendamiento y revocación de secretos, además de un registro de auditoría detallado que se asienta en todo momento. Vault también cuenta con una API HTTP, lo que lo convierte en la opción ideal para almacenar credenciales en implementaciones diseminadas orientadas al servicio, como Kubernetes.

      Packer y Terraform, también desarrollados por Hashicorp, pueden usarse juntos para crear e implementar imágenes de Vault. En este flujo de trabajo, los desarrolladores pueden usar Packer para escribir imágenes inmutables para diferentes plataformas desde un único archivo de configuración, que especifica lo que la imagen debería contener. Posteriormente, Terraform implementa tantas instancias personalizadas de las imágenes creadas como sea necesario.

      En este tutorial, usará Packer para crear una instantánea inmutable del sistema con Vault instalado y orquestará su implementación usando Terraform. Al final, tendrá un sistema automatizado para implementar Vault, lo que le permitirá centrarse en trabajar con Vault y no en el proceso de instalación y aprovisionamiento subyacente.

      Requisitos previos

      • Packer instalado en su máquina local. Para acceder a instrucciones, consulte la documentación oficial.
      • Terraform instalado en su computadora local. Consulte la documentación oficial para obtener ayuda.
      • Un token de acceso personal (clave de API) con permisos de lectura y escritura para su cuenta de DigitalOcean. Para aprender a crear uno, consulte Cómo crear un token de acceso personal en los documentos.
      • Una clave SSH que usará para la autenticación con los Droplets de Vault implementados, disponible en su equipo local y añadida a su cuenta de DigitalOcean. También necesitará su huella; podrá copiarla de la página Seguridad de su cuenta una vez que la haya añadido. Consulte la documentación de DigitalOcean para hallar instrucciones detalladas o el tutorial Cómo configurar claves SSH.

      Paso 1: Crear una plantilla de Packer

      En este paso, escribirá un archivo de configuración de Packer, llamado template, que indicará a Packer cómo crear una imagen que tenga Vault previamente instalado. Escribirá la configuración en formato JSON, un formato de archivo de configuración legible para humanos que se usa comúnmente.

      A los efectos de este tutorial, almacenará todos los archivos en ~/vault-orchestration. Cree el directorio ejecutando el siguiente comando:

      • mkdir ~/vault-orchestration

      Diríjase a este:

      Almacenará los archivos de configuración para Packer y Terraform por separado, en subdirectorios diferentes. Créelos usando el siguiente comando:

      Debido a que primero trabajará con Packer, diríjase al directorio de este:

      Usar variables de plantilla

      Almacenar datos privados y secretos de la aplicación en un archivo de variables independiente es una excelente alternativa para mantenerlos fuera de su plantilla. Cuando se cree la imagen, Packer sustituirá las variables referenciadas por sus valores. Codificar de forma rígida valores secretos en su plantilla es un riesgo de seguridad, en particular si se compartirá con miembros del equipo o se dispondrá en sitios públicos, como GitHub.

      Los almacenará en el subdirectorio packer, en un archivo llamado variables.json. Créelo usando su editor de texto favorito:

      Añada las siguientes líneas:

      ~/vault-orchestration/packer/variables.json

      {
          "do_token": "your_do_api_key",
          "base_system_image": "ubuntu-18-04-x64",
          "region": "nyc3",
          "size": "s-1vcpu-1gb"
      }
      

      El archivo de variables consiste en un diccionario JSON, que asigna los nombres de variables a sus valores. Usará estas variables en la plantilla que está a punto de crear. Si lo desea, puede editar los valores básicos de imagen, región y tamaño del Droplet conforme a los documentos para desarrolladores.

      Recuerde sustituir your_do_api_key por la clave de API que creó como parte de los requisitos previos, y luego guarde y cierre el archivo.

      Crear compiladores y aprovisionadores

      Una vez que esté listo el archivo de variables, creará la plantilla de Packer.

      Guardará la plantilla de Packer para Vault en un archivo llamado template.json. Créelo usando su editor de texto:

      Añada las siguientes líneas:

      ~/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"
               ]
          }]
      }
      

      En la plantilla, se definen conjuntos de compiladores y aprovisionadores. Los compiladores indican a Packer la manera de compilar la imagen del sistema (según su tipo) y el espacio en el que se almacenará, mientras que los aprovisionadores contienen conjuntos de acciones que Packer debería realizar en el sistema antes de convertirlo en una imagen inmutable; por ejemplo, instalar o configurar software. Sin aprovisionadores, obtendría una imagen de sistema básica intacta. Tanto los compiladores como los aprovisionadores exponen parámetros para una personalización del flujo de trabajo más completa.

      Primero se define un compilador individual del tipo digitalocean; esto significa que, cuando se le ordene crear una imagen, Packer usará los parámetros proporcionados para crear un Droplet temporal del tamaño definido usando la clave de API proporcionada, con la imagen del sistema básica y en la región especificada. El formato para obtener una variable es {{user 'variable_name'}}, donde la parte resaltada es su nombre.

      Cuando se proporcione el Droplet temporal, el proveedor establecerá conexión con él usando SSH con el nombre de usuario especificado y de forma secuencial ejecutará todos los proveedores definidos antes de crear una instantánea de DigitalOcean desde el Droplet y eliminarlo.

      Es del tipo shell, que ejecutará los comando determinados en el destino. Los comandos pueden especificarse inline, como un conjunto de cadenas, o definirse en archivos de secuencias de comandos independientes si su inserción en la plantilla dificulta la manipulación debido al tamaño. Los comandos de la plantilla esperarán 30 segundos para que el sistema arranque, y luego descargarán y desempaquetarán Vault 1.3.2. Consulte la página oficial de descarga de Vault y sustituya el enlace de los comandos por una versión más reciente de Linux, si está disponible.

      Cuando termine, guarde y cierre el archivo.

      Para verificar la validez de su plantilla, ejecute el siguiente comando:

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

      Packer acepta una ruta al archivo de variables a través del argumento -var-file.

      Verá el siguiente resultado:

      Output

      Template validated successfully.

      Si ve un error, Packer especificará con exactitud dónde se produjo para que pueda corregirlo.

      Ahora tiene una plantilla en funcionamiento que produce una imagen con Vault instalado, con su clave de API y otros parámetros definidos en un archivo independiente. Con esto, estará listo para invocar Packer y crear la instantánea.

      Paso 2: Crear la instantánea

      En este paso, creará una instantánea de DigitalOcean desde su plantilla usando el comando build de Packer.

      Para crear su instantánea, ejecute el siguiente comando:

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

      Este comando tardará un tiempo en ejecutarse. Verá muchos resultados que tendrán un aspecto similar a 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 '...'

      Packer registra todos los pasos que realizó al crear su plantilla. La última línea contiene el nombre de la instantánea (como packer-1581537927) y su ID entre paréntesis marcado en rojo. Anote el ID de la instantánea, lo necesitará en el paso siguiente.

      Si el proceso de creación falla debido a errores de API, espere unos minutos y realice un nuevo intento.

      Creó una instantánea de DigitalOcean conforme a su plantilla. La instantánea tiene Vault previamente instalado, y ahora puede implementar Droplets con él como su imagen de sistema. En el siguiente paso, escribirá la configuración de Terraform para automatizar dichas implementaciones.

      Paso 3: Escribir la configuración de Terraform

      En este paso, escribirá la configuración de Terraform para automatizar implementaciones de Droplets de la instantánea que contiene el Vault que acaba de crear usando Packer.

      Antes de escribir la configuración real de Terraform para implementar Vault desde la instantánea creada previamente, primero deberá configurar el proveedor de DigitalOcean. Diríjase al subdirectorio terraform ejecutando lo siguiente:

      • cd ~/vault-orchestration/terraform

      A continuación, cree un archivo llamado do-provider.tf en el que almacenará el proveedor:

      Añada las siguientes líneas:

      ~/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
      }
      

      Este archivo declara las variables del parámetro y proporciona al proveedor digitalocean una clave de API. Posteriormente, usará estas variables en su plantilla de Terraform, pero primero deberá especificar sus valores. Para ello, Terraform admite la especificación de valores de variables en un archivo de definiciones de variables de forma similar a Packer. El nombre del archivo debe terminar en .tfvars o .tfvars.jason. Luego, pasará ese archivo a Terraform usando el argumento –var-file.

      Guarde y cierre el archivo.

      Cree un archivo de definiciones de variables llamado definitions.tfvars usando su editor de texto:

      Añada las siguientes líneas:

      ~/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
      

      Recuerde sustituir your_do_api_key, your_ssh_key_fingerprint y your_do_snapshot_id por la clave de API de su cuenta, la huella de su clave SSH y el ID de la instantánea que anotó en el paso anterior, respectivamente. Los parámetros do_region y do_size deben tener los mismos valores que en el archivo de variables de Packer. Si desea implementar varias instancias de una vez, ajuste instance_count según su valor deseado.

      Cuando termine, guarde y cierre el archivo.

      Para obtener más información sobre el proveedor de Terraform de DigitalOcean, consulte los documentos oficiales.

      Guardará la configuración de la implementación de la instantánea de Vault en un archivo llamado deployment.tf, en el directorio terraform. Créelo usando su editor de texto:

      Añada las siguientes líneas:

      ~/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."
      }
      

      Aquí, define un único recurso del tipo digitalocean_droplet llamado vault. A continuación, establecerá sus parámetros según los valores de las variables y añadirá una clave SSH (usando la huella de esta) de su cuenta de DigitalOcean al recurso del Droplet. Finalmente, usará output para mostrar las direcciones IP de todas las instancias recién implementadas en la consola.

      Guarde y cierre el archivo.

      Antes de aplicar cualquier otra acción a la configuración de su implementación, deberá inicializar el directorio como proyecto de Terraform:

      Verá el siguiente 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.

      Cuando se inicia un directorio como un proyecto, Terraform lee los archivos de configuración disponibles y los complementos de descargas considerados necesarios, según lo que se registre en el resultado.

      Ahora cuenta con la configuración de Terraform para implementar su instantánea de Vault. Podrá proceder a validarla e implementarla en un Droplet.

      Paso 4: Implementar Vault usando Terraform

      En esta sección, verificará su configuración de Terraform usando el comando validate. Una vez que se verifique correctamente, utilizará apply en ella e implementará un Droplet como resultado.

      Ejecute el siguiente comando para probar la validez de su configuración:

      Verá el siguiente resultado:

      Output

      Success! The configuration is valid.

      A continuación, ejecute el comando plan para ver qué intentará hacer Terraform cuando se aprovisione la infraestructura según su configuración:

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

      Terraform acepta un archivo de definiciones de variables a través del parámetro -var-file.

      El resultado será similar a este:

      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.

      El signo + verde al principio de la línea resource "digitalocean_droplet" "vault" implica que Terraform creará un nuevo Droplet llamado vault y usará los parámetros que siguen. Esto es correcto; por ello, ahora podrá implementar el plan ejecutando terraform apply:

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

      Introduzca yes cuando se solicite. Después de unos minutos, el Droplet finalizará el aprovisionamiento y verá un resultado similar 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" }

      En el resultado, Terraform registra las acciones que realizó (en este caso, para crear un Droplet) y muestra su dirección IP pública al final. La usará para establecer conexión con su nuevo Droplet en el siguiente paso.

      Creó un nuevo Droplet a partir de la instantánea que contiene Vault y ahora está listo para verificarlo.

      Paso 5: Verificar su Droplet implementado

      En este paso, accederá a su nuevo Droplet usando SSH y verificará que Vault se haya instalado correctamente.

      En equipos con Windows, puede usar un software como Kitty o Putty para establecer conexión con el Droplet con una clave SSH.

      En equipos con Linux o macOS, puede usar el comando ssh disponible para la conexión.

      Responda yes cuando se solicite. Una vez que acceda, inicie Vault ejecutanto lo siguiente:

      Verá el resultado de “ayuda”, que tiene este aspecto:

      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

      Puede cerrar la conexión escribiendo exit.

      De esta manera, habrá verificado verificó que su Droplet recién implementado se creó a partir de la instantánea que realizó y que Vault se instaló correctamente.

      Conclusión

      Ahora dispone de un sistema automatizado para implementar Hashicorp Vault en Droplets de DigitalOcean usando Terraform y Packer. Ahora puede implementar tantos servidores Vault como necesite. Para comenzar a usar Vault, deberá iniciarlo y realizar algunas configuraciones adicionales. Para hallar instrucciones sobre cómo hacerlo, consulte la documentación oficial.

      Para hallar más tutoriales sobre Terraform, consulte nuestra página de contenido de Terraform.



      Source link