Como Implantar O Vault E O Consul Da Hashicorp Com O Docker Swarm

Vejamos como implantar o Vault e o Consul da Hashicorp na DigitalOcean com o Docker Swarm.

Após a conclusão, você será capaz de:

  1. Provisionar hosts na DigitalOcean com Docker Machine
  2. Configurar um cluster do Docker Swarm para ser executado na DigitalOcean
  3. Execute o Vault e o Consul no Docker Swarm

Principais dependências:

  • Docker v20.10.8
  • Docker-Compose v1.29.2
  • Máquina Docker v0.16.2
  • Cofre v1.8.3
  • Cônsul v1.10.3

Cônsul

Crie um novo diretório de projeto:

$ mkdir vault-consul-swarm && cd vault-consul-swarm

Em seguida, adicione um arquivo docker-compose.yml à raiz do projeto:

version: "3.8"

services:

  server-bootstrap:
    image: consul:1.10.3
    ports:
      - 8500:8500
    command: "agent -server -bootstrap-expect 3 -ui -client 0.0.0.0 -bind '{{ GetInterfaceIP \"eth0\" }}'"

  server:
    image: consul:1.10.3
    command: "agent -server -retry-join server-bootstrap -client 0.0.0.0 -bind '{{ GetInterfaceIP \"eth0\" }}'"
    deploy:
      replicas: 2
    depends_on:
      - server-bootstrap

  client:
    image: consul:1.10.3
    command: "agent -retry-join server-bootstrap -client 0.0.0.0 -bind '{{ GetInterfaceIP \"eth0\" }}'"
    deploy:
      replicas: 2
    depends_on:
      - server-bootstrap

networks:
  default:
    external: true
    name: core

Essa configuração deve parecer familiar.

  1. Consulte a seção Compose File da postagem do blog Running Flask on Docker Swarm para obter mais informações sobre como usar um arquivo de composição para o modo Docker Swarm.
  2. Revise o guia do Consul e do Docker para obter informações sobre a configuração do Consul acima.

Enxame Docker

Inscreva-se em uma conta da DigitalOcean (se você ainda não tiver uma) e gere um token de acesso para poder acessar a API da DigitalOcean.

Adicione o token ao seu ambiente:

$ export DIGITAL_OCEAN_ACCESS_TOKEN=[your_digital_ocean_token]

Gire três gotas:

$ for i in 1 2 3; do
    docker-machine create \
      --driver digitalocean \
      --digitalocean-region "nyc1" \
      --digitalocean-image=debian-10-x64 \
      --engine-install-url "https://releases.rancher.com/install-docker/19.03.9.sh" \
      --digitalocean-access-token $DIGITAL_OCEAN_ACCESS_TOKEN \
      node-$i;
done

Inicialize o modo Swarm no primeiro nó, node-1:

$ docker-machine ssh node-1 -- docker swarm init --advertise-addr $(docker-machine ip node-1)

Use o token de junção da saída do comando anterior para adicionar os dois nós restantes ao Swarm como trabalhadores:

$ for i in 2 3; do
    docker-machine ssh node-$i -- docker swarm join --token YOUR_JOIN_TOKEN HOST:PORT;
done

Por exemplo:

for i in 2 3; do
    docker-machine ssh node-$i -- docker swarm join --token SWMTKN-1-18xrfgcgq7k6krqr7tvav3ydx5c5104y662lzh4pyct2t0ror3-e3ed1ggivhf8z15i40z6x55g5 67.205.165.166:2377;
done

Você deveria ver:

This node joined a swarm as a worker.
This node joined a swarm as a worker.

Aponte o daemon do Docker para node-1, crie uma rede de sobreposição anexável (chamada core) e implante a pilha:

$ eval $(docker-machine env node-1)
$ docker network create -d overlay --attachable core
$ docker stack deploy --compose-file=docker-compose.yml secrets

Liste os serviços na pilha:

$ docker stack ps -f "desired-state=running" secrets

Você deve ver algo semelhante a:

ID             NAME                         IMAGE          NODE     DESIRED STATE   CURRENT STATE
b5f5eycrhf3o   secrets_client.1             consul:1.10.3   node-1   Running         Running 7 seconds ago
zs7a5t8khcew   secrets_server.1             consul:1.10.3   node-2   Running         Running 9 seconds ago
qnhtlan6m0sp   secrets_server-bootstrap.1   consul:1.10.3   node-1   Running         Running 7 seconds ago
u61eycesmsl7   secrets_client.2             consul:1.10.3   node-2   Running         Running 9 seconds ago
vgpql8lfy5fi   secrets_server.2             consul:1.10.3   node-3   Running         Running 9 seconds ago

Grab the IP associated with node-1:

$ docker-machine ip node-1

Then, test out the Consul UI in your browser at http://YOUR_MACHINE_IP:8500/ui. There should be three running services and five nodes.

serviços de interface do cônsul

nós de interface do usuário do cônsul

Vault

Add the vault service to docker-compose.yml:

vault:
  image: vault:1.8.3
  deploy:
    replicas: 1
  ports:
    - 8200:8200
  environment:
    - VAULT_ADDR=http://127.0.0.1:8200
    - VAULT_LOCAL_CONFIG={"backend":{"consul":{"address":"http://server-bootstrap:8500","path":"vault/"}},"listener":{"tcp":{"address":"0.0.0.0:8200","tls_disable":1}},"ui":true, "disable_mlock":true}
  command: server
  depends_on:
    - consul

Take note of the VAULT_LOCAL_CONFIG environment variable:

{
  "backend": {
    "consul": {
      "address": "http://server-bootstrap:8500",
      "path": "vault/"
    }
  },
  "listener": {
    "tcp": {
      "address": "0.0.0.0:8200",
      "tls_disable": 1
    }
  },
  "ui": true,
  "disable_mlock": true
}

Review the Consul Backend section from the Managing Secrets with Vault and Consul blog post for more info. Also, setting disable_mlock to true is not recommended for production environments; however, it must be enabled since --cap-add is not available in Docker Swarm mode. See the following GitHub issues for details:

  1. --cap-add=IPC_LOCK unavailable in docker swarm
  2. Missing from Swarmmode --cap-add

Test

Re-deploy the stack:

$ docker stack deploy --compose-file=docker-compose.yml secrets

Wait a few seconds for the services to spin up, then check the status:

$ docker stack ps -f "desired-state=running" secrets

Again, you should see something similar to:

ID             NAME                         IMAGE           NODE      DESIRED STATE   CURRENT STATE
xtfsetfrbrs7   secrets_client.1             consul:1.10.3   node-3    Running         Running 19 minutes ago
ydqxexgiyzb2   secrets_client.2             consul:1.10.3   node-1    Running         Running 19 minutes ago
izlku3y6j8rp   secrets_server-bootstrap.1   consul:1.10.3   node-2    Running         Running 19 minutes ago
zqpkcrhrix2x   secrets_server.1             consul:1.10.3   node-1    Running         Running 19 minutes ago
kmlxuhxw1akv   secrets_server.2             consul:1.10.3   node-2    Running         Running 19 minutes ago
wfmscoj53m39   secrets_vault.1              vault:1.8.3     node-3    Running         Running about a minute ago

Next, ensure Vault is listed on the "Services" section of the Consul UI:

serviços de interface do cônsul

You should now be able to interact with Vault via the CLI, HTTP API, and the UI. Start by initializing and unsealing Vault. Then, log in and create a new secret.

Remove the nodes once done:

$ docker-machine rm node-1 node-2 node-3 -y

Automation Script

Finally, let's create a quick script to automate the deployment process:

  1. Provision three DigitalOcean droplets with Docker Machine
  2. Configure Docker Swarm mode
  3. Add nodes to the Swarm
  4. Deploy the stack

Add a new file called deploy.sh to the project root:

#!/bin/bash


echo "Spinning up three droplets..."

for i in 1 2 3; do
  docker-machine create \
    --driver digitalocean \
    --digitalocean-region "nyc1" \
    --digitalocean-image=debian-10-x64 \
    --engine-install-url "https://releases.rancher.com/install-docker/19.03.9.sh" \
    --digitalocean-access-token $DIGITAL_OCEAN_ACCESS_TOKEN \
    node-$i;
done


echo "Initializing Swarm mode..."

docker-machine ssh node-1 -- docker swarm init --advertise-addr $(docker-machine ip node-1)


echo "Adding the nodes to the Swarm..."

TOKEN=`docker-machine ssh node-1 docker swarm join-token worker | grep token | awk '{ print $5 }'`

for i in 2 3; do
  docker-machine ssh node-$i \
    -- docker swarm join --token ${TOKEN} $(docker-machine ip node-1):2377;
done


echo "Creating networking..."

eval $(docker-machine env node-1)
docker network create -d overlay --attachable core


echo "Deploying the stack..."

docker stack deploy --compose-file=docker-compose.yml secrets

Try it out!

$ sh deploy.sh

Bring down the droplets once done:

$ docker-machine rm node-1 node-2 node-3 -y

The code can be found in the vault-consul-swarm repo. Cheers!

Fonte:  https://testdrive.io

#vault #docker 

What is GEEK

Buddha Community

Como Implantar O Vault E O Consul Da Hashicorp Com O Docker Swarm

Como Implantar O Vault E O Consul Da Hashicorp Com O Docker Swarm

Vejamos como implantar o Vault e o Consul da Hashicorp na DigitalOcean com o Docker Swarm.

Após a conclusão, você será capaz de:

  1. Provisionar hosts na DigitalOcean com Docker Machine
  2. Configurar um cluster do Docker Swarm para ser executado na DigitalOcean
  3. Execute o Vault e o Consul no Docker Swarm

Principais dependências:

  • Docker v20.10.8
  • Docker-Compose v1.29.2
  • Máquina Docker v0.16.2
  • Cofre v1.8.3
  • Cônsul v1.10.3

Cônsul

Crie um novo diretório de projeto:

$ mkdir vault-consul-swarm && cd vault-consul-swarm

Em seguida, adicione um arquivo docker-compose.yml à raiz do projeto:

version: "3.8"

services:

  server-bootstrap:
    image: consul:1.10.3
    ports:
      - 8500:8500
    command: "agent -server -bootstrap-expect 3 -ui -client 0.0.0.0 -bind '{{ GetInterfaceIP \"eth0\" }}'"

  server:
    image: consul:1.10.3
    command: "agent -server -retry-join server-bootstrap -client 0.0.0.0 -bind '{{ GetInterfaceIP \"eth0\" }}'"
    deploy:
      replicas: 2
    depends_on:
      - server-bootstrap

  client:
    image: consul:1.10.3
    command: "agent -retry-join server-bootstrap -client 0.0.0.0 -bind '{{ GetInterfaceIP \"eth0\" }}'"
    deploy:
      replicas: 2
    depends_on:
      - server-bootstrap

networks:
  default:
    external: true
    name: core

Essa configuração deve parecer familiar.

  1. Consulte a seção Compose File da postagem do blog Running Flask on Docker Swarm para obter mais informações sobre como usar um arquivo de composição para o modo Docker Swarm.
  2. Revise o guia do Consul e do Docker para obter informações sobre a configuração do Consul acima.

Enxame Docker

Inscreva-se em uma conta da DigitalOcean (se você ainda não tiver uma) e gere um token de acesso para poder acessar a API da DigitalOcean.

Adicione o token ao seu ambiente:

$ export DIGITAL_OCEAN_ACCESS_TOKEN=[your_digital_ocean_token]

Gire três gotas:

$ for i in 1 2 3; do
    docker-machine create \
      --driver digitalocean \
      --digitalocean-region "nyc1" \
      --digitalocean-image=debian-10-x64 \
      --engine-install-url "https://releases.rancher.com/install-docker/19.03.9.sh" \
      --digitalocean-access-token $DIGITAL_OCEAN_ACCESS_TOKEN \
      node-$i;
done

Inicialize o modo Swarm no primeiro nó, node-1:

$ docker-machine ssh node-1 -- docker swarm init --advertise-addr $(docker-machine ip node-1)

Use o token de junção da saída do comando anterior para adicionar os dois nós restantes ao Swarm como trabalhadores:

$ for i in 2 3; do
    docker-machine ssh node-$i -- docker swarm join --token YOUR_JOIN_TOKEN HOST:PORT;
done

Por exemplo:

for i in 2 3; do
    docker-machine ssh node-$i -- docker swarm join --token SWMTKN-1-18xrfgcgq7k6krqr7tvav3ydx5c5104y662lzh4pyct2t0ror3-e3ed1ggivhf8z15i40z6x55g5 67.205.165.166:2377;
done

Você deveria ver:

This node joined a swarm as a worker.
This node joined a swarm as a worker.

Aponte o daemon do Docker para node-1, crie uma rede de sobreposição anexável (chamada core) e implante a pilha:

$ eval $(docker-machine env node-1)
$ docker network create -d overlay --attachable core
$ docker stack deploy --compose-file=docker-compose.yml secrets

Liste os serviços na pilha:

$ docker stack ps -f "desired-state=running" secrets

Você deve ver algo semelhante a:

ID             NAME                         IMAGE          NODE     DESIRED STATE   CURRENT STATE
b5f5eycrhf3o   secrets_client.1             consul:1.10.3   node-1   Running         Running 7 seconds ago
zs7a5t8khcew   secrets_server.1             consul:1.10.3   node-2   Running         Running 9 seconds ago
qnhtlan6m0sp   secrets_server-bootstrap.1   consul:1.10.3   node-1   Running         Running 7 seconds ago
u61eycesmsl7   secrets_client.2             consul:1.10.3   node-2   Running         Running 9 seconds ago
vgpql8lfy5fi   secrets_server.2             consul:1.10.3   node-3   Running         Running 9 seconds ago

Grab the IP associated with node-1:

$ docker-machine ip node-1

Then, test out the Consul UI in your browser at http://YOUR_MACHINE_IP:8500/ui. There should be three running services and five nodes.

serviços de interface do cônsul

nós de interface do usuário do cônsul

Vault

Add the vault service to docker-compose.yml:

vault:
  image: vault:1.8.3
  deploy:
    replicas: 1
  ports:
    - 8200:8200
  environment:
    - VAULT_ADDR=http://127.0.0.1:8200
    - VAULT_LOCAL_CONFIG={"backend":{"consul":{"address":"http://server-bootstrap:8500","path":"vault/"}},"listener":{"tcp":{"address":"0.0.0.0:8200","tls_disable":1}},"ui":true, "disable_mlock":true}
  command: server
  depends_on:
    - consul

Take note of the VAULT_LOCAL_CONFIG environment variable:

{
  "backend": {
    "consul": {
      "address": "http://server-bootstrap:8500",
      "path": "vault/"
    }
  },
  "listener": {
    "tcp": {
      "address": "0.0.0.0:8200",
      "tls_disable": 1
    }
  },
  "ui": true,
  "disable_mlock": true
}

Review the Consul Backend section from the Managing Secrets with Vault and Consul blog post for more info. Also, setting disable_mlock to true is not recommended for production environments; however, it must be enabled since --cap-add is not available in Docker Swarm mode. See the following GitHub issues for details:

  1. --cap-add=IPC_LOCK unavailable in docker swarm
  2. Missing from Swarmmode --cap-add

Test

Re-deploy the stack:

$ docker stack deploy --compose-file=docker-compose.yml secrets

Wait a few seconds for the services to spin up, then check the status:

$ docker stack ps -f "desired-state=running" secrets

Again, you should see something similar to:

ID             NAME                         IMAGE           NODE      DESIRED STATE   CURRENT STATE
xtfsetfrbrs7   secrets_client.1             consul:1.10.3   node-3    Running         Running 19 minutes ago
ydqxexgiyzb2   secrets_client.2             consul:1.10.3   node-1    Running         Running 19 minutes ago
izlku3y6j8rp   secrets_server-bootstrap.1   consul:1.10.3   node-2    Running         Running 19 minutes ago
zqpkcrhrix2x   secrets_server.1             consul:1.10.3   node-1    Running         Running 19 minutes ago
kmlxuhxw1akv   secrets_server.2             consul:1.10.3   node-2    Running         Running 19 minutes ago
wfmscoj53m39   secrets_vault.1              vault:1.8.3     node-3    Running         Running about a minute ago

Next, ensure Vault is listed on the "Services" section of the Consul UI:

serviços de interface do cônsul

You should now be able to interact with Vault via the CLI, HTTP API, and the UI. Start by initializing and unsealing Vault. Then, log in and create a new secret.

Remove the nodes once done:

$ docker-machine rm node-1 node-2 node-3 -y

Automation Script

Finally, let's create a quick script to automate the deployment process:

  1. Provision three DigitalOcean droplets with Docker Machine
  2. Configure Docker Swarm mode
  3. Add nodes to the Swarm
  4. Deploy the stack

Add a new file called deploy.sh to the project root:

#!/bin/bash


echo "Spinning up three droplets..."

for i in 1 2 3; do
  docker-machine create \
    --driver digitalocean \
    --digitalocean-region "nyc1" \
    --digitalocean-image=debian-10-x64 \
    --engine-install-url "https://releases.rancher.com/install-docker/19.03.9.sh" \
    --digitalocean-access-token $DIGITAL_OCEAN_ACCESS_TOKEN \
    node-$i;
done


echo "Initializing Swarm mode..."

docker-machine ssh node-1 -- docker swarm init --advertise-addr $(docker-machine ip node-1)


echo "Adding the nodes to the Swarm..."

TOKEN=`docker-machine ssh node-1 docker swarm join-token worker | grep token | awk '{ print $5 }'`

for i in 2 3; do
  docker-machine ssh node-$i \
    -- docker swarm join --token ${TOKEN} $(docker-machine ip node-1):2377;
done


echo "Creating networking..."

eval $(docker-machine env node-1)
docker network create -d overlay --attachable core


echo "Deploying the stack..."

docker stack deploy --compose-file=docker-compose.yml secrets

Try it out!

$ sh deploy.sh

Bring down the droplets once done:

$ docker-machine rm node-1 node-2 node-3 -y

The code can be found in the vault-consul-swarm repo. Cheers!

Fonte:  https://testdrive.io

#vault #docker 

Neil  Morgan

Neil Morgan

1660603740

Como Configurar E Usar Os Projetos Vault E Consul Da Hashicorp

O tutorial a seguir detalha como configurar e usar os projetos Vault e Consul da Hashicorp para armazenar e gerenciar segredos com segurança.

Começaremos girando uma única instância do Vault em um contêiner do Docker e, em seguida, passaremos ao gerenciamento de segredos estáticos e dinâmicos junto com o recurso "criptografia como serviço" do Vault. Em seguida, adicionaremos o Consul à mistura e veremos como dimensionar o Vault.

Principais dependências:

  • Docker v20.10.8
  • Docker-Compose v1.29.2
  • Cofre v1.8.2
  • Cônsul v1.10.2

Objetivos

Ao final deste tutorial, você deverá ser capaz de:

  1. Explique o que é o Vault e por que você pode querer usá-lo
  2. Descrever a arquitetura básica do Vault juntamente com segredos dinâmicos e estáticos, os vários back-ends (armazenamento, segredo, autenticação, auditoria) e como o Vault pode ser usado como uma "criptografia como serviço"
  3. Configurar e executar o Vault e o Consul com o Docker
  4. Acelere o Vault com o back-end do sistema de arquivos
  5. Iniciar e deslacrar o Vault
  6. Autenticar no Vault
  7. Configure um back-end de auditoria para registrar todas as interações com o Vault
  8. Trabalhe com segredos estáticos e dinâmicos por meio da CLI, API HTTP e IU
  9. Crie uma política do Vault para limitar o acesso a um caminho específico
  10. Use o back-end do Transit como uma "criptografia como serviço"
  11. Configurar o Consul para trabalhar com o Vault como back-end de armazenamento para segredos
  12. Defina um período de concessão personalizado para um segredo e revogue um segredo antes do final desse período

O que é Cofre?

O Vault é uma ferramenta de código aberto usada para armazenar e gerenciar segredos com segurança.

O que é um segredo? Segredos, no contexto deste tutorial, são informações seguras ou de identificação pessoal, como credenciais de banco de dados, chaves SSH, nomes de usuário e senhas, credenciais do AWS IAM, tokens de API, números de CPF, números de cartão de crédito, apenas para citar alguns.

Reserve um momento para pensar em como sua equipe atualmente gerencia e distribui segredos:

  1. Quem tem acesso a eles?
  2. Quem os administra?
  3. Como você controla quem tem acesso a eles?
  4. Como seus aplicativos os obtêm?
  5. Como eles são atualizados?
  6. Como são revogados?

O Vault fornece respostas a essas perguntas e ajuda a resolver os seguintes problemas em relação ao gerenciamento de segredos:

ProblemasObjetivos do Vault
Os segredos estão por toda parte.O Vault é a única fonte de verdade para todos os segredos.
Eles geralmente não são criptografados.O Vault gerencia a criptografia (durante o trânsito e em repouso) imediatamente.
É difícil gerá-los dinamicamente.Os segredos podem ser gerados dinamicamente.
É ainda mais difícil arrendar e revogá-los.Os segredos podem ser alugados e revogados.
Não há trilha de auditoria.Há uma trilha de auditoria para gerar e usar segredos.

O Vault tem várias peças móveis, então pode levar algum tempo para se atualizar com a arquitetura geral. Reserve um momento para revisar o guia de arquitetura , observando os seguintes back-ends:

Processo internoUsarExemplos
ArmazenarOnde os segredos são armazenadosConsul *, Filesystem *, In-Memory, PostgreSQL, S3
SegredoLida com segredos estáticos ou dinâmicosAWS *, bancos de dados, chave/valor *, RabbitMQ, SSH
AutenticaçãoLida com autenticação e autorizaçãoAWS, Azure, Google Cloud, GitHub, Tokens *, nome de usuário e senha
AuditoriaRegistra todas as solicitações e respostasArquivo *, Syslog, Soquete

*usado neste tutorial

Com isso, vamos começar a usar o Vault.

Back-end do sistema de arquivos

Para começar a funcionar rapidamente, usaremos o back-end do Filesystem para armazenar segredos em repouso.

O back-end do sistema de arquivos deve ser usado apenas para desenvolvimento local ou implantação do Vault de servidor único, pois não suporta alta disponibilidade.

Crie um novo diretório de projeto:

$ mkdir vault-consul-docker && cd vault-consul-docker

Em seguida, adicione as seguintes pastas:

└── vault
    ├── config
    ├── data
    ├── logs
    └── policies

Adicione um Dockerfile ao diretório "vault":

# base image
FROM alpine:3.14

# set vault version
ENV VAULT_VERSION 1.8.2

# create a new directory
RUN mkdir /vault

# download dependencies
RUN apk --no-cache add \
      bash \
      ca-certificates \
      wget

# download and set up vault
RUN wget --quiet --output-document=/tmp/vault.zip https://releases.hashicorp.com/vault/${VAULT_VERSION}/vault_${VAULT_VERSION}_linux_amd64.zip && \
    unzip /tmp/vault.zip -d /vault && \
    rm -f /tmp/vault.zip && \
    chmod +x /vault

# update PATH
ENV PATH="PATH=$PATH:$PWD/vault"

# add the config file
COPY ./config/vault-config.json /vault/config/vault-config.json

# expose port 8200
EXPOSE 8200

# run vault
ENTRYPOINT ["vault"]

Em seguida, adicione um arquivo docker-compose.yml à raiz do projeto:

version: '3.8'

services:

  vault:
    build:
      context: ./vault
      dockerfile: Dockerfile
    ports:
      - 8200:8200
    volumes:
      - ./vault/config:/vault/config
      - ./vault/policies:/vault/policies
      - ./vault/data:/vault/data
      - ./vault/logs:/vault/logs
    environment:
      - VAULT_ADDR=http://127.0.0.1:8200
      - VAULT_API_ADDR=http://127.0.0.1:8200
    command: server -config=/vault/config/vault-config.json
    cap_add:
      - IPC_LOCK

Adicione um arquivo de configuração chamado vault-config.json a "vault/config":

{
  "backend": {
    "file": {
      "path": "vault/data"
    }
  },
  "listener": {
    "tcp":{
      "address": "0.0.0.0:8200",
      "tls_disable": 1
    }
  },
  "ui": true
}

Aqui, configuramos o Vault para usar o back-end do sistema de arquivos, definimos o ouvinte para o Vault, desabilitamos o TLS e habilitamos a interface do usuário do Vault . Revise os documentos para obter mais informações sobre como configurar o Vault.

Agora podemos construir a imagem e girar o contêiner:

$ docker-compose up -d --build

Puxe os logs do Docker para verificar se não houve erros na compilação:

$ docker-compose logs

Você deve ver algo semelhante a:

Attaching to vault-consul-docker_vault_1
vault_1  | ==> Vault server configuration:
vault_1  |
vault_1  |              Api Address: http://127.0.0.1:8200
vault_1  | 2021-09-08T14:48:35.014Z [INFO]  proxy environment: http_proxy="" https_proxy="" no_proxy=""
vault_1  |                      Cgo: disabled
vault_1  |          Cluster Address: https://127.0.0.1:8201
vault_1  |               Go Version: go1.16.7
vault_1  |               Listener 1: tcp (addr: "0.0.0.0:8200", cluster address: "0.0.0.0:8201", max_request_duration: "1m30s", max_request_size: "33554432", tls: "disabled")
vault_1  |                Log Level: info
vault_1  |                    Mlock: supported: true, enabled: true
vault_1  |            Recovery Mode: false
vault_1  |                  Storage: file
vault_1  |                  Version: Vault v1.8.2
vault_1  |              Version Sha: aca76f63357041a43b49f3e8c11d67358496959f
vault_1  |
vault_1  | ==> Vault server started! Log data will stream in below:
vault_1  |

Inicializando e deslacrando

Inicie uma sessão bash no contêiner em execução:

$ docker-compose exec vault bash

Dentro do shell, inicialize o Vault:

bash-5.1# vault operator init

Anote as chaves de unseal e o token raiz inicial. Você precisará fornecer três das chaves de remoção de lacre sempre que o servidor do Vault for relacrado ou reiniciado.

Por que 3 chaves? Revise o Compartilhamento Secreto de Shamir .

Agora você pode desbloquear o Vault usando três das chaves:

bash-5.1# vault operator unseal
Unseal Key (will be hidden):

Execute este comando mais duas vezes, usando chaves diferentes a cada vez. Uma vez feito, certifique- Sealedse de false:

Key             Value
---             -----
Seal Type       shamir
Initialized     true
Sealed          false
Total Shares    5
Threshold       3
Version         1.8.2
Storage Type    file
Cluster Name    vault-cluster-8fcf9d05
Cluster ID      d86e0274-ad9c-d2c1-d6ec-baeab410797b
HA Enabled      false

Usando o token raiz, agora você pode autenticar:

bash-5.1# vault login
Token (will be hidden):

Você deve ver algo semelhante a:

Success! You are now authenticated. The token information displayed below
is already stored in the token helper. You do NOT need to run "vault login"
again. Future Vault requests will automatically use this token.

Key                  Value
---                  -----
token                s.c0kYHWiOTqQvtR8JuSeTz6sZ
token_accessor       3FQJVxOY5C1brzlHHQSFaCdZ
token_duration       ∞
token_renewable      false
token_policies       ["root"]
identity_policies    []
policies             ["root"]

Tenha em mente que isso usa a política de raiz. Na produção, você desejará configurar políticas com diferentes níveis de acesso. Veremos como fazer isso em breve.

inicialização do cofre

O Vault agora está sem lacre e pronto para uso.

Auditoria

Antes de testarmos a funcionalidade, vamos habilitar um Dispositivo de Auditoria :

bash-5.1# vault audit enable file file_path=/vault/logs/audit.log

Success! Enabled the file audit device at: file/

Agora você deve poder visualizar os logs localmente em "cofre/logs". Para testar, execute o seguinte comando para visualizar todos os dispositivos de auditoria habilitados:

bash-5.1# vault audit list

Path     Type    Description
----     ----    -----------
file/    file    n/a

A solicitação e a resposta subsequente devem ser registradas em vault/logs/audit.log . Dê uma olhada.

Segredos

Existem dois tipos de segredos no Vault: estático e dinâmico .

Segredos estáticos (pense em Redis ou Memcached criptografados) têm intervalos de atualização, mas não expiram, a menos que sejam revogados explicitamente. Eles são definidos antecipadamente com o back-end de chave/valor (anteriormente o back-end "genérico") e, em seguida, compartilhados.

armazenamento secreto seguro

Os segredos dinâmicos são gerados sob demanda. Eles obrigaram os arrendamentos e geralmente expiram após um curto período de tempo. Como eles não existem até que sejam acessados, há menos exposição - portanto, os segredos dinâmicos são muito mais seguros. O Vault é fornecido com vários back-ends dinâmicos -- ou seja, AWS , Databases , Google Cloud , Consul e RabbitMQ .

Revise a postagem do blog Por que precisamos de segredos dinâmicos para obter mais informações sobre as vantagens de usar segredos dinâmicos.

Segredos estáticos

O Vault pode ser gerenciado por meio da CLI , HTTP API ou UI .

CLI

Ainda dentro da sessão bash no container, podemos criar, ler, atualizar e excluir segredos. Também veremos como versionar e reverter segredos.

Habilite segredos com o seguinte comando:

bash-5.1# vault secrets enable kv

Success! Enabled the kv secrets engine at: kv/

Crie um novo segredo com uma chave de bare um valor de preciousdentro do kv/foocaminho:

bash-5.1# vault kv put kv/foo bar=precious

Success! Data written to: kv/foo

Ler:

bash-5.1# vault kv get kv/foo

=== Data ===
Key    Value
---    -----
bar    precious

Para trabalhar com diferentes versões de uma chave específica, precisaremos atualizar para a v2 do back-end de chave/valor :

bash-5.1# vault kv enable-versioning kv/

Success! Tuned the secrets engine at: kv/

Adicione a versão 2 atualizando o valor para copper:

bash-5.1# vault kv put kv/foo bar=copper

Key              Value
---              -----
created_time     2021-09-08T18:23:14.4154928Z
deletion_time    n/a
destroyed        false
version          2

Leia a versão 1:

bash-5.1# vault kv get -version=1 kv/foo

====== Metadata ======
Key              Value
---              -----
created_time     2021-09-08T18:22:37.2548824Z
deletion_time    n/a
destroyed        false
version          1

=== Data ===
Key    Value
---    -----
bar    precious

Leia a versão 2:

bash-5.1# vault kv get -version=2 kv/foo

====== Metadata ======
Key              Value
---              -----
created_time     2021-09-08T18:23:14.4154928Z
deletion_time    n/a
destroyed        false
version          2

=== Data ===
Key    Value
---    -----
bar    copper

Exclua a versão mais recente (por exemplo, versão 2):

bash-5.1# vault kv delete kv/foo

Success! Data deleted (if it existed) at: kv/foo

Excluir versão 1:

bash-5.1# vault kv delete -versions=1 kv/foo

Success! Data deleted (if it existed) at: kv/foo

Você também pode recuperar:

bash-5.1# vault kv undelete -versions=1 kv/foo

Success! Data written to: kv/undelete/foo

Excluir é semelhante a uma exclusão reversível. Se você quiser remover os metadados subjacentes, terá que usar o comando destroy :

bash-5.1# vault kv destroy -versions=1 kv/foo

Success! Data written to: kv/destroy/foo

Revise v1 e v2 para visualizar todos os comandos disponíveis.

Anote o log de auditoria. Cada uma das solicitações acima foi registrada!

API

Você também pode interagir com o Vault por meio da API HTTP . Faremos solicitações na v2 da API. Abra uma nova guia de terminal e defina o token raiz como uma variável de ambiente:

$ export VAULT_TOKEN=your_token_goes_here

Crie um novo segredo chamado foocom um valor de world:

$ curl \
    -H "X-Vault-Token: $VAULT_TOKEN" \
    -H "Content-Type: application/json" \
    -X POST \
    -d '{ "data": { "foo": "world" } }' \
    http://127.0.0.1:8200/v1/kv/data/hello

Leia o segredo:

$ curl \
    -H "X-Vault-Token: $VAULT_TOKEN" \
    -X GET \
    http://127.0.0.1:8200/v1/kv/data/hello

A resposta JSON deve conter uma datachave com um valor semelhante a:

"data": {
  "data":{
    "foo": "world"
  },
  "metadata": {
    "created_time": "2021-09-08T18:30:32.5140484Z",
    "deletion_time": "",
    "destroyed": false,
    "version": 1
  }
}

API de cofre

Tente adicionar novas versões, excluir e destruir por conta própria.

IU

A interface do usuário deve estar em execução em http://localhost:8200/ui/vault . Use o token raiz para fazer login. Em seguida, explore o back-end de chave/valor por conta própria:

interface do cofre

Políticas

Até agora, usamos a política de raiz para interagir com a API. Vamos configurar uma política que tenha apenas acesso de leitura.

Adicione um novo arquivo de configuração chamado app-policy.json a "vault/policies":

{
  "path": {
    "kv/data/app/*": {
      "policy": "read"
    }
  }
}

Crie uma nova política de volta na sessão bash:

bash-5.1# vault policy write app /vault/policies/app-policy.json

Success! Uploaded policy: app

Em seguida, crie um novo token:

bash-5.1# vault token create -policy=app

Key                  Value
---                  -----
token                s.ZOUMx3RIhVRhI4ijlZg8KXRQ
token_accessor       TT53xOxbIfGjI7l4392gjXcg
token_duration       768h
token_renewable      true
token_policies       ["app" "default"]
identity_policies    []
policies             ["app" "default"]

Dentro de outra nova guia do terminal (agora você deve ter três), adicione a VAULT_TOKENvariável de ambiente com o novo token:

$ export VAULT_TOKEN=your_token_goes_here

Tente ler o foosegredo que definimos anteriormente:

$ curl \
    -H "X-Vault-Token: $VAULT_TOKEN" \
    -X GET \
    http://127.0.0.1:8200/v1/kv/data/hello

Você não deve ter as permissões corretas para visualizar esse segredo:

{
  "errors":[
    "1 error occurred:\n\t* permission denied\n\n"
  ]
}

Por que não podemos nem ler? Volte para a configuração de política em vault-config.json . kv/data/app/*indica que a política só pode ler do appcaminho.

Como você provavelmente já notou, quase tudo no Vault é baseado em caminhos.

De volta à sessão bash no contêiner, adicione um novo segredo ao app/testcaminho:

bash-5.1# vault kv put kv/app/test ping=pong

Key              Value
---              -----
created_time     2021-09-08T18:40:35.2694047Z
deletion_time    n/a
destroyed        false
version          1

Você deve conseguir visualizar o segredo usando o token associado à apppolítica:

$ curl \
    -H "X-Vault-Token: $VAULT_TOKEN" \
    -X GET \
    http://127.0.0.1:8200/v1/kv/data/app/test

As políticas também podem ser gerenciadas na interface do usuário:

interface do cofre

Criptografia como um serviço

Antes de analisarmos os segredos dinâmicos, vamos analisar rapidamente o back-end do Transit , que pode ser usado como uma "criptografia como serviço" para:

  • Criptografar e descriptografar dados "em trânsito" sem armazená-los no Vault
  • Integrando facilmente a criptografia ao fluxo de trabalho do seu aplicativo

De volta à sessão bash no contêiner, ative o Transit:

bash-5.1# vault secrets enable transit

Success! Enabled the transit secrets engine at: transit/

Configure uma chave de criptografia nomeada:

bash-5.1# vault write -f transit/keys/foo

Success! Data written to: transit/keys/foo

Criptografar:

bash-5.1# vault write transit/encrypt/foo plaintext=$(base64 <<< "my precious")

Key           Value
---           -----
ciphertext    vault:v1:cFnk5AQLE9Mg+mZ7Ej17vRmYT5aqheikdZQ1FC4vre5jAod0L/uHDA==

Descriptografar:

bash-5.1# vault write transit/decrypt/foo ciphertext=vault:v1:cFnk5AQLE9Mg+mZ7Ej17vRmYT5aqheikdZQ1FC4vre5jAod0L/uHDA==

Key          Value
---          -----
plaintext    bXkgcHJlY2lvdXMK

Decodificar:

bash-5.1# base64 -d <<< "bXkgcHJlY2lvdXMK"

my precious

Teste-o também na interface do usuário:

interface do cofre

Segredos dinâmicos

Conforme mencionado, o Vault oferece suporte a vários back-ends de segredo dinâmicos para gerar segredos dinamicamente quando necessário. Por exemplo, com os back-ends da AWS e do Google Cloud , você pode criar credenciais de acesso com base nas políticas do IAM. Enquanto isso, o back-end de bancos de dados gera credenciais de banco de dados com base nas funções configuradas.

Segredos dinâmicos:

  • são gerados sob demanda
  • têm acesso limitado com base na função
  • são alugados por um período de tempo
  • pode ser revogado
  • vem com uma trilha de auditoria

Vejamos como gerar credenciais da AWS usando o back-end da AWS.

Credenciais da AWS

Habilite o back-end de segredos da AWS:

bash-5.1# vault secrets enable -path=aws aws

Success! Enabled the aws secrets engine at: aws/

Autenticar:

bash-5.1# vault write aws/config/root access_key=foo secret_key=bar

Success! Data written to: aws/config/root

Certifique-se de substituir fooe barpelo ID da chave de acesso e chave secreta da AWS, respectivamente.

Criar função:

bash-5.1# vault write aws/roles/ec2-read credential_type=iam_user policy_document=-<<EOF
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "Stmt1426528957000",
      "Effect": "Allow",
      "Action": [
        "ec2:*"
      ],
      "Resource": [
        "*"
      ]
    }
  ]
}
EOF

Success! Data written to: aws/roles/ec2-read

Aqui, criamos uma nova função baseada em , que é uma políticaAmazonEC2ReadOnlyAccess gerenciada pela AWS . Como o nome sugere, ele dá aos usuários acesso somente leitura ao console do EC2; eles não podem executar nenhuma ação ou criar novos recursos. Você também pode usar uma política em linha para criar uma função personalizada com base em suas necessidades individuais. Veremos um exemplo disso em breve. Consulte os documentos do AWS Secrets Engine para obter mais informações.

Lembre -se : Segredos dinâmicos são gerados apenas quando solicitados (ou seja, um aplicativo da Web solicita acesso ao S3). Eles não estão disponíveis na loja antes disso.

Crie um novo conjunto de credenciais:

bash-5.1# vault read aws/creds/ec2-read

Key                Value
---                -----
lease_id           aws/creds/ec2-read/9KdO6J7KVBiSwOPEvwrqqALG
lease_duration     768h
lease_renewable    true
access_key         AKIAZ4DZAKZKEULSDW5A
secret_key         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
security_token     <nil>

Agora você deve conseguir ver o usuário na seção "Usuários" no console do IAM na AWS:

Sinto muito

Arrendamentos e Revogação

Nesta seção, veremos rapidamente como definir um período de concessão personalizado e revogar um segredo antes do final desse período.

Crie uma nova função da AWS:

bash-5.1# vault write aws/roles/foo credential_type=iam_user policy_document=-<<EOF
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "Stmt1426528957000",
      "Effect": "Allow",
      "Action": [
        "ec2:*"
      ],
      "Resource": [
        "*"
      ]
    }
  ]
}
EOF

Success! Data written to: aws/roles/foo

Observe lease_durationquando você cria uma nova credencial da AWS:

bash-5.1# vault read aws/creds/foo

Key                Value
---                -----
lease_id           aws/creds/foo/F0oBbnBIHEoz0ywVVtbuJB7r
lease_duration     768h
lease_renewable    true
access_key         AKIAZ4DZAKZKLJKB7CPX
secret_key         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
security_token     <nil>

E se você quisesse que o período de concessão de todos os segredos dinâmicos do AWS IAM fosse de 30 minutos?

bash-5.1# vault write aws/config/lease lease=1800s lease_max=1800s

Neste exemplo, como lease_maxé igual a lease, você não poderá renovar o token. Se você definir lease_maxcomo 3600s, poderá renovar a concessão uma vez. Para saber mais, consulte o guia Tokens e Leases .

Crie uma nova credencial:

bash-5.1# vault read aws/creds/foo

Key                Value
---                -----
lease_id           aws/creds/foo/xQlJpKDS1ljE9Awz0aywXgbB
lease_duration     30m
lease_renewable    true
access_key         AKIAZ4DZAKZKJPL5OM5W
secret_key         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
security_token     <nil>

Quer revogar rapidamente esta credencial? Pegue o lease_ide depois execute:

bash-5.1# vault lease revoke aws/creds/foo/xQlJpKDS1ljE9Awz0aywXgbB

Quer revogar todas as credenciais da AWS?

bash-5.1# vault lease revoke -prefix aws/

Consulte o guia Lease, Renew e Revoke para obter mais informações sobre esses conceitos.

Back-end do cônsul

Até agora, estamos usando o backend Filesystem . Isso não será dimensionado além de um único servidor, portanto, não aproveita a alta disponibilidade do Vault. Felizmente, existem vários outros back-ends de armazenamento , como o back-end Consul , projetados para sistemas distribuídos.

Para configurar o Consul , comece atualizando o arquivo docker-compose.yml :

version: '3.8'

services:

  vault:
    build:
      context: ./vault
      dockerfile: Dockerfile
    ports:
      - 8200:8200
    volumes:
      - ./vault/config:/vault/config
      - ./vault/policies:/vault/policies
      - ./vault/data:/vault/data
      - ./vault/logs:/vault/logs
    environment:
      - VAULT_ADDR=http://127.0.0.1:8200
      - VAULT_API_ADDR=http://127.0.0.1:8200
    command: server -config=/vault/config/vault-config.json
    cap_add:
      - IPC_LOCK
    depends_on:
      - consul

  consul:
    build:
      context: ./consul
      dockerfile: Dockerfile
    ports:
      - 8500:8500
    command: agent -server -bind 0.0.0.0 -client 0.0.0.0 -bootstrap-expect 1 -config-file=/consul/config/config.json
    volumes:
      - ./consul/config/consul-config.json:/consul/config/config.json
      - ./consul/data:/consul/data

Adicione um novo diretório na raiz do projeto chamado "consul" e adicione um novo Dockerfile nesse diretório recém-criado:

# base image
FROM alpine:3.14

# set consul version
ENV CONSUL_VERSION 1.10.2

# create a new directory
RUN mkdir /consul

# download dependencies
RUN apk --no-cache add \
      bash \
      ca-certificates \
      wget

# download and set up consul
RUN wget --quiet --output-document=/tmp/consul.zip https://releases.hashicorp.com/consul/${CONSUL_VERSION}/consul_${CONSUL_VERSION}_linux_amd64.zip && \
    unzip /tmp/consul.zip -d /consul && \
    rm -f /tmp/consul.zip && \
    chmod +x /consul/consul

# update PATH
ENV PATH="PATH=$PATH:$PWD/consul"

# add the config file
COPY ./config/consul-config.json /consul/config/config.json

# expose ports
EXPOSE 8300 8400 8500 8600

# run consul
ENTRYPOINT ["consul"]

Em seguida, dentro do diretório "consul" adicione dois novos diretórios: "config" e "data". Em seguida, dentro de "config", adicione um arquivo de configuração chamado consul-config.json :

{
  "datacenter": "localhost",
  "data_dir": "/consul/data",
  "log_level": "DEBUG",
  "server": true,
  "ui": true,
  "ports": {
    "dns": 53
  }
}

Certifique-se de revisar as opções de configuração dos documentos do Consul para obter mais informações sobre as opções acima.

O diretório "consul" agora deve se parecer com:

├── Dockerfile
├── config
│   └── consul-config.json
└── data

Saia da sessão do bash. Desative o contêiner e atualize o arquivo de configuração do Vault:

{
  "backend": {
    "consul": {
      "address": "consul:8500",
      "path": "vault/"
    }
  },
  "listener": {
    "tcp":{
      "address": "0.0.0.0:8200",
      "tls_disable": 1
    }
  },
  "ui": true
}

Então, agora estamos usando o backend Consul em vez do Filesystem. Usamos o nome do serviço, consul, como parte do endereço. A pathchave define o caminho no armazenamento de chave/valor do Consul onde os dados do Vault serão armazenados.

Limpe todos os arquivos e pastas dentro do diretório "vault/data" para remover o backend do sistema de arquivos. Construa as novas imagens e gire os contêineres:

$ docker-compose down
$ docker-compose up -d --build

Certifique-se de que tudo está bem navegando em seu navegador para http://localhost:8500/ui :

cônsul ui

Teste isso na CLI ou na interface do usuário.

CLI

Crie uma nova sessão bash no contêiner do Vault:

$ docker-compose exec vault bash

Então corra:

# Init
bash-5.1# vault operator init

# Unseal
bash-5.1# vault operator unseal

# Authenticate
bash-5.1# vault login

# Enable secrets
bash-5.1# vault secrets enable kv

# Add a new static secret
bash-5.1# vault kv put kv/foo bar=precious

# Read it back
bash-5.1# vault kv get kv/foo

IU

cônsul do cofre

Observe como não há arquivos ou pastas dentro de "cofre/dados". Por que você acha que é isso?

Quer adicionar outro servidor Consul à mistura? Adicione um novo serviço ao docker-compose.yml :

consul-worker:
  build:
    context: ./consul
    dockerfile: Dockerfile
  command: agent -server -join consul -config-file=/consul/config/config.json
  volumes:
    - ./consul/config/consul-config.json:/consul/config/config.json
  depends_on:
    - consul

Aqui, usamos o comando join para conectar esse agente a um cluster existente. Observe como simplesmente tivemos que referenciar o nome do serviço: consul.

Então:

  1. Sair da sessão bash (se necessário)
  2. Derrube os recipientes
  3. Limpe o diretório de dados em "consul/data" (Por quê?)
  4. Gire os contêineres de volta e teste

cônsul ui

Conclusão

Neste tutorial, vimos como configurar e executar o Vault e o Consul dentro de um contêiner do Docker. Agora você deve ter uma compreensão clara de como interagir com o Vault e realizar operações básicas.

Pegue o código final do repositório vault-consul-docker . Confira também a apresentação .

Fonte:  https://testdrive.io

#vault #consul 

Panmure  Anho

Panmure Anho

1601301859

Kubernetes vs. Docker Swarm (k8 vs Docker Swarm)

Basically, both Kubernetes and Docker Swarm both are the container orchestration tool. The rise in interest to containers has in turn brought in higher demands for their deployment and management. Both Kubernetes and Docker Swarm are important tools that are used to deploy containers inside a cluster. So the question arises here is which one to use?

So lets discuss one by one and see the the differances between them.

Introduction to Kubernetes:

The name Kubernetes originates from Greek, meaning helmsman or pilot. Kubernetes is an open-source, portable, and extensible platform for managing containerized workload and services. That facilitates both declarative configuration and automation. Kubernetes manage the containers that run the applications and ensure that there is no downtime into a huge scale production environment.

Introduction to Docker swarm:

Docker swarm is a container orchestration tool, meaning that it allows the user to manage multiple containers deployed across multiple host machines. Docker Swarm is designed to work around four key principles:

  1. Less cluttered/heavy and with just working methodology
  2. No Single Point of Failure option for Docker Swarm
  3. Secure due to auto-generation of security certificates.
  4. Compatibility with Backward versions easily.

Here you get to know that both in some manner are the same , So now let’s check out the differences and see:

#devops #docker #docker swarm #kubernetes #swarm

Cómo Implementar Vault Y Consul De Hashicorp Con Docker Swarm

Veamos cómo implementar Vault y Consul de Hashicorp en DigitalOcean con Docker Swarm.

Al finalizar, podrá:

  1. Aprovisione hosts en DigitalOcean con Docker Machine
  2. Configure un clúster de Docker Swarm para que se ejecute en DigitalOcean
  3. Ejecute Vault y Consul en Docker Swarm

Dependencias principales:

  • Ventana acoplable v20.10.8
  • Docker-Componer v1.29.2
  • Docker-Máquina v0.16.2
  • Bóveda v1.8.3
  • Cónsul v1.10.3

Cónsul

Cree un nuevo directorio de proyecto:

$ mkdir vault-consul-swarm && cd vault-consul-swarm

Luego, agregue un archivo docker-compose.yml a la raíz del proyecto:

version: "3.8"services:  server-bootstrap:    image: consul:1.10.3    ports:      - 8500:8500    command: "agent -server -bootstrap-expect 3 -ui -client 0.0.0.0 -bind '{{ GetInterfaceIP \"eth0\" }}'"  server:    image: consul:1.10.3    command: "agent -server -retry-join server-bootstrap -client 0.0.0.0 -bind '{{ GetInterfaceIP \"eth0\" }}'"    deploy:      replicas: 2    depends_on:      - server-bootstrap  client:    image: consul:1.10.3    command: "agent -retry-join server-bootstrap -client 0.0.0.0 -bind '{{ GetInterfaceIP \"eth0\" }}'"    deploy:      replicas: 2    depends_on:      - server-bootstrapnetworks:  default:    external: true    name: core

Esta configuración debería resultarle familiar.

  1. Consulte la sección Componer archivo de la publicación de blog Running Flask en Docker Swarm para obtener más información sobre el uso de un archivo de composición para el modo Docker Swarm.
  2. Consulte la guía de Consul y Docker para obtener información sobre la configuración de Consul anterior.

Enjambre Docker

Regístrese para obtener una cuenta de DigitalOcean (si aún no tiene una) y luego genere un token de acceso para poder acceder a la API de DigitalOcean.

Agregue el token a su entorno:

$ export DIGITAL_OCEAN_ACCESS_TOKEN=[your_digital_ocean_token]

Haz girar tres gotas:

$ for i in 1 2 3; do    docker-machine create \      --driver digitalocean \      --digitalocean-region "nyc1" \      --digitalocean-image=debian-10-x64 \      --engine-install-url "https://releases.rancher.com/install-docker/19.03.9.sh" \      --digitalocean-access-token $DIGITAL_OCEAN_ACCESS_TOKEN \      node-$i;done

Inicialice el modo Swarm en el primer nodo node-1:

$ docker-machine ssh node-1 -- docker swarm init --advertise-addr $(docker-machine ip node-1)

Use el token de unión de la salida del comando anterior para agregar los dos nodos restantes al Swarm como trabajadores:

$ for i in 2 3; do    docker-machine ssh node-$i -- docker swarm join --token YOUR_JOIN_TOKEN HOST:PORT;done

Por ejemplo:

for i in 2 3; do    docker-machine ssh node-$i -- docker swarm join --token SWMTKN-1-18xrfgcgq7k6krqr7tvav3ydx5c5104y662lzh4pyct2t0ror3-e3ed1ggivhf8z15i40z6x55g5 67.205.165.166:2377;done

Debería ver:

This node joined a swarm as a worker.This node joined a swarm as a worker.

Apunte el demonio de Docker a node-1, cree una red de superposición conectable (llamada core) e implemente la pila:

$ eval $(docker-machine env node-1)$ docker network create -d overlay --attachable core$ docker stack deploy --compose-file=docker-compose.yml secrets

Enumere los servicios en la pila:

$ docker stack ps -f "desired-state=running" secrets

Deberías ver algo similar a:

ID             NAME                         IMAGE          NODE     DESIRED STATE   CURRENT STATEb5f5eycrhf3o   secrets_client.1             consul:1.10.3   node-1   Running         Running 7 seconds agozs7a5t8khcew   secrets_server.1             consul:1.10.3   node-2   Running         Running 9 seconds agoqnhtlan6m0sp   secrets_server-bootstrap.1   consul:1.10.3   node-1   Running         Running 7 seconds agou61eycesmsl7   secrets_client.2             consul:1.10.3   node-2   Running         Running 9 seconds agovgpql8lfy5fi   secrets_server.2             consul:1.10.3   node-3   Running         Running 9 seconds ago

Tome la IP asociada con node-1:

$ docker-machine ip node-1

Luego, pruebe la interfaz de usuario de Consul en su navegador en http://YOUR_MACHINE_IP:8500/ui . Debe haber tres servicios en ejecución y cinco nodos.

servicios de interfaz de usuario del cónsul

nodos de la interfaz de usuario del cónsul

Bóveda

Agregue el vaultservicio a docker-compose.yml :

vault:  image: vault:1.8.3  deploy:    replicas: 1  ports:    - 8200:8200  environment:    - VAULT_ADDR=http://127.0.0.1:8200    - VAULT_LOCAL_CONFIG={"backend":{"consul":{"address":"http://server-bootstrap:8500","path":"vault/"}},"listener":{"tcp":{"address":"0.0.0.0:8200","tls_disable":1}},"ui":true, "disable_mlock":true}  command: server  depends_on:    - consul

Toma nota de la VAULT_LOCAL_CONFIGvariable de entorno:

{  "backend": {    "consul": {      "address": "http://server-bootstrap:8500",      "path": "vault/"    }  },  "listener": {    "tcp": {      "address": "0.0.0.0:8200",      "tls_disable": 1    }  },  "ui": true,  "disable_mlock": true}

Consulte la sección Backend de Consul de la publicación de blog Administración de secretos con Vault y Consul para obtener más información. Además, no se recomienda establecer disabled_mlock en trueentornos de producción; sin embargo, debe estar habilitado ya --cap-addque no está disponible en el modo Docker Swarm. Consulte los siguientes problemas de GitHub para obtener más detalles:

  1. --cap-add=IPC_LOCK no disponible en Docker Swarm
  2. Falta en Swarmmode --cap-add

Prueba

Vuelva a implementar la pila:

$ docker stack deploy --compose-file=docker-compose.yml secrets

Espere unos segundos para que los servicios se activen y luego verifique el estado:

$ docker stack ps -f "desired-state=running" secrets

De nuevo, deberías ver algo similar a:

ID             NAME                         IMAGE           NODE      DESIRED STATE   CURRENT STATExtfsetfrbrs7   secrets_client.1             consul:1.10.3   node-3    Running         Running 19 minutes agoydqxexgiyzb2   secrets_client.2             consul:1.10.3   node-1    Running         Running 19 minutes agoizlku3y6j8rp   secrets_server-bootstrap.1   consul:1.10.3   node-2    Running         Running 19 minutes agozqpkcrhrix2x   secrets_server.1             consul:1.10.3   node-1    Running         Running 19 minutes agokmlxuhxw1akv   secrets_server.2             consul:1.10.3   node-2    Running         Running 19 minutes agowfmscoj53m39   secrets_vault.1              vault:1.8.3     node-3    Running         Running about a minute ago

A continuación, asegúrese de que Vault aparezca en la sección "Servicios" de la interfaz de usuario de Consul:

servicios de interfaz de usuario del cónsul

Ahora debería poder interactuar con Vault a través de la CLI, la API HTTP y la interfaz de usuario. Comience por inicializar y abrir Vault. Luego, inicie sesión y cree un nuevo secreto.

Retire los nodos una vez hecho:

$ docker-machine rm node-1 node-2 node-3 -y

Guión de automatización

Finalmente, creemos un script rápido para automatizar el proceso de implementación:

  1. Aprovisione tres gotitas de DigitalOcean con Docker Machine
  2. Configurar el modo Docker Swarm
  3. Agregar nodos al enjambre
  4. Implementar la pila

Agrega un nuevo archivo llamado deployment.sh a la raíz del proyecto:

#!/bin/bashecho "Spinning up three droplets..."for i in 1 2 3; do  docker-machine create \    --driver digitalocean \    --digitalocean-region "nyc1" \    --digitalocean-image=debian-10-x64 \    --engine-install-url "https://releases.rancher.com/install-docker/19.03.9.sh" \    --digitalocean-access-token $DIGITAL_OCEAN_ACCESS_TOKEN \    node-$i;doneecho "Initializing Swarm mode..."docker-machine ssh node-1 -- docker swarm init --advertise-addr $(docker-machine ip node-1)echo "Adding the nodes to the Swarm..."TOKEN=`docker-machine ssh node-1 docker swarm join-token worker | grep token | awk '{ print $5 }'`for i in 2 3; do  docker-machine ssh node-$i \    -- docker swarm join --token ${TOKEN} $(docker-machine ip node-1):2377;doneecho "Creating networking..."eval $(docker-machine env node-1)docker network create -d overlay --attachable coreecho "Deploying the stack..."docker stack deploy --compose-file=docker-compose.yml secrets

¡Pruébalo!

$ sh deploy.sh

Baje las gotas una vez hecho:

$ docker-machine rm node-1 node-2 node-3 -y

El código se puede encontrar en el repositorio vault-consul-swarm . ¡Salud!

Fuente:  https://testdriven.io

#vault #docker 

Iliana  Welch

Iliana Welch

1595249460

Docker Explained: Docker Architecture | Docker Registries

Following the second video about Docker basics, in this video, I explain Docker architecture and explain the different building blocks of the docker engine; docker client, API, Docker Daemon. I also explain what a docker registry is and I finish the video with a demo explaining and illustrating how to use Docker hub

In this video lesson you will learn:

  • What is Docker Host
  • What is Docker Engine
  • Learn about Docker Architecture
  • Learn about Docker client and Docker Daemon
  • Docker Hub and Registries
  • Simple demo to understand using images from registries

#docker #docker hub #docker host #docker engine #docker architecture #api