Fala pessoal! Hoje trouxe um quickstart rápido do seu primeiro Cluster de Swarm utilizando as máquinas EC2 na AWS. Pra quem não viu o primeiro post, abordamos a criação de um Cluster de Testes utilizando Docker Machine e o driver do Virtualbox. Nesse vamos partir de um principio parecido, porém utilizando o driver da Amazon EC2. Mas antes precisamos configurar todo o ambiente da Amazon para que o mesmo comporte nossas necessidades para com o Docker Swarm.

Caso não tenha visto, recomendo que leia o primeiro post:

Criando uma VPC

No console da AWS, acesse o painel do VPC. Em seguida vamos criar nossa primeira VPC

  1. Clique em “Create VPC”. Dentro dele vamos criar uma VPC Simples com com um range de IP’s IPV4.
  2. O range default será de 172.31.0.0/24. Modifique a vontade aqui, de primeiro momento não fará diferença

Umas coisas muito importantes devem ser guardadas nesse passo, o VPC ID, nossa Zone ID e nossa Subnet. Usaremos ele mais tarde para criar nodes dentro da VPC automaticamente.
No exemplo estaremos utilizando a Virginia, então nossa zona de testes será a us-east

  • VPC ID do exemplo: vpc-ea72618c
  • Zone: us-east

Criando uma Subnet na VPC

Para gerenciar uma comunicação mais segura e uniforme entre nossos nodes do cluster futuramente, vamos precisar estabelecer uma conexão entre as máquinas através de subnets.

  1. Dentro do painel da VPC, vamos encontrar a opção Subnets e “Create Subnet”.
  2. Vamos atribuir um nome amigável que eu vou chamar de swarm-subnet e anexar a VPC do Swarm que acabamos de criar.
  3. Vamos manter o mesmo range de IP’s associados a VPC durante a criação da mesma em IPV4 CIDR block e deixar o resto das opções default, caso queira especificar uma zona para a subnet ser criada, pode ficar a vontade dentro das opções da região. Guarde no ID da Subnet, ele será importante.

Após a criação da subnet, vamos pegar a zona que ela foi criada. Você pode especificar uma Availability Zone ou deixar a Amazon decidir qual é melhor pra você. No caso a minha foi criada em us-east-1c

  • Zona da Subnet: us-east-1c

Criando um Internet Gateway e Routing Table

Quando trabalhamos com VPC, podemos selecionar quais níveis das nossas subnets vão ter acesso a internet. Para isso funcionar, precisamos seguir os passos a seguir:

  1. Ir no nosso painel de configurações da VPC e encontrar a opção “Internet Gateways”.
  2. Caso não exista um Default, clique em “Create Internet Gateway”. Coloque um nome amigável e em seguida
  3. Clique com o botão direito e selecione “Attach to VPC”. Selecione a VPC do Swarm e salve. Isso irá nos fornecer um acesso a internet dentro da mesma.

Em seguida, vamos configurar nossa Routing Tables para acessar a internet provisionada pelo Internet Gateway.

  1. No mesmo menu da VPC, procure pela opção Route Table.
  2. Procure pela Route Table do Swarm, vá até a aba Routes e clique em editar.
  3. Vamos criar uma nova rule, tendo certeza de que nosso endereço 0.0.0.0/0 esteja sendo redirecionado para o ID do Internet Gateway que acabamos de criar.

Criando as Credenciais de Acesso.

Agora vamos brincar com o IAM. O recurso de gerenciamento de usuários e credenciais da Amazon. No painel, vamos seguir os seguintes Babysteps

  1. Acessar o Console do IAM
  2. Acessar o Menu “Users”
  3. Clicar no Botão “Add User”
  4. Next: Permissions

No menu, vamos criar um usuário chamado “swarm-admin” e dar a ele permissão de Programmatic Access. Nesse nível de permissão, o usuário poderá administrar nossos recursos da AWS por meio da Access Key, tendo permissão para manipular os SDK’s, CLI e API’s da Amazon. Nosso Cluster será configurado a partir desses recursos.

Após prosseguirmos para o próximo passo, vamos ter que atribuir permissões para o nosso usuário swarm-admin. Aqui é muito aconselhavem configurar tudo com muito critério, porém como isso é só uma simples demo, vamos dar Administrative Access para nosso user.

Nessa nova Aba, vamos Clicar no menu “Attach existing policies directly” e selecionar a opção do “Modo Deus” da Amazon chamada AdministratorAccess.

Lembre-se: O AdministratorAccess é uma policy que deve ser utilizada com muita sabedoria, talvez o melhor uso pra ela é definitivamente NÃO USAR e atribuir aos usuários somente a autorização que eles precisam pra existir e nada mais.

O próximo passo é avançar para o Review e depois finalmente criar nosso usuário. Após criado, vamos ter acesso aos Access Key ID e ao Secret access key do usuário com a opção de fazer o Download via CSV. Pode fazer a vontade! Vamos configurar nosso cluster utilizando essas credenciais.

Security Groups

Para termos uma segurança básica dentro do cluster, vamos criar um security group chamado swarm-cluster. Para criar um Secutiry Group, seguiremos esses Babysteps:

  1. Entrar no painel de EC2 do Console da Amazon
  2. Ir até o menu Network & Security
  3. Clicar em Security Groups
  4. Create Security Group
Configurando o Acesso Externo
Liberando todo o tráfego para as máquinas de dentro da VPC

Criaremos algumas regras simples, só para testes:

  • Abriremos a porta 80 para o mundo onde vamos publicar nossa API de testes.
  • Abriremos a porta SSH para o IP da (cafeteria onde eu estou) da sua empresa para limitar o acesso para um único ponto (Essa regra não é obrigatória para o teste).
  • Abriremos a porta 8080 para um futuro lab legal. Se quiser pode limitar aqui também, vai ser uma tarefa mais administrativa.
  • Abriremos todo o tráfego para as máquinas de dentro da VPC que compartilharem o security group do Swarm. Esse passo é importante!

Vamos iniciar nossa fabrica de Nodes de forma muito semelhante a do primeiro artigo, utilizando o Docker-Machine.

Criando nosso Host Manager

Para criar as máquinas do cluster, precisamos primeiramente uma máquina Admin, que vai fazer todo o gerenciamento de configurações e etc. Nessa ideia temos duas formas de se fazer:

1. O Jeito Certo — Criar uma EC2, com uma chave, procedimento padrão e executar toda instalação do Docker, Docker-machine, compose e etc e iniciar as configurações de lá.

2. O Jeito Rápido — Exportar as credenciais de acesso na sua máquina local e criar o cluster a partir dela.

Para fins de teste, o modo 2 não faz mal algum. Mas caso vá trabalhar em um ambiente real, essa prática não é aconselhada. Fique por criar um host admin dentro da sua VPC e deixar as coisas mais corretas possíveis. Como eu estou brincando de Free Tier, vou ter que economizar aqui :)

Configurando as credencias da Amazon no CLI

Vamos ter que instalar nosso aws-cli e configurar nossas credenciais de acesso para a nova máquina. Lembrando: Para produção, selecione uma EC2 dedicada do seu cluster para isso. Pode ser a mais barata que tiver, contanto que suas chaves de acesso não corram risco de se perder por coisa boba.

$ aws configure AWS Access Key ID [None]: AKIAIN4FY7RYWYDUVVV
AWS Secret Access Key [None]: OswzeuXPpkD8ORIrHStd3pIFWhZNIcprMrsVVVV
Default region name [None]:
Default output format [None]:

Criando nosso Nodes Manager

Nosso cluster será composto por 3 nodes como de costume, o manager que será um host chave que executará tarefas administrativas e 2 workers que vão apenas portar os containers da nossa aplicação.

Agora vamos criar nosso primeiro host chamado de Manager01

$ docker-machine create -d amazonec2 --amazonec2-vpc-id vpc-ea72618c --amazonec2-subnet-id subnet-d8709bf4 --amazonec2-region us-east-1 --amazonec2-zone c --amazonec2-instance-type t2.micro  --amazonec2-security-group swarm-cluster manager01

Com esse comando enorme, vamos criar nossa primeira instância denominada manager01 com todos os dados que coletamos nos passos anteriores, como VPC ID, Subnet ID, Região, Zona e etc. Após rodarmos esse primeiro comando, vamos ver que uma nova instância foi lançada no painel da Amazon.

Após a criação do host, podemos conectar no mesmo via SSH ou exportando as variáveis de ambiente para nossa shell local. Abordamos isso no primeiro post, é o mesmo esquema

Para listar as máquinas que temos criadas dentro da docker-machine

$ docker-machine ls

Para exportar as variáveis de ambiente para termos um controle maior sobre a máquina, podemos utilizar

Caso esteja usando o Bash
$ eval $(docker-machine env manager01)
Caso esteja usando Fish Shell
$ eval (docker-machine env manager01)

Ou podemos conectar via SSH no host

$ docker-machine ssh manager01

Iniciando o Cluster

Para criar o cluster, vamos precisar do IP da interface de rede interna do host na VPC, por default sempre fica na interface eth0, então vamos pegar o IP da mesma

$ docker-machine ssh manager01 ifconfig eth0                                               4021ms  Ter 25 Abr 00:57:40 2017
eth0 Link encap:Ethernet HWaddr 12:bb:25:f6:56:1e
inet addr:172.31.0.15 Bcast:172.31.0.255 Mask:255.255.255.0
inet6 addr: fe80::10bb:25ff:fef6:561e/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:9001 Metric:1
RX packets:114106 errors:0 dropped:0 overruns:0 frame:0
TX packets:4211 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:168656996 (168.6 MB) TX bytes:515251 (515.2 KB)

Agora vamos literalmente iniciar o Cluster para conseguirmos ingressar nossos hosts

$ docker swarm init --advertise-addr eth0

Após rodarmos o comando, será nos entregue o comando já pronto para ingressar novos hosts dentro do cluster. Será algo parecido com:

Swarm initialized: current node (zjazxrj3x3y4emqa5a74xx7oi) is now a manager.To add a worker to this swarm, run the following command:docker swarm join \
--token SWMTKN-1-4zklgl3qjitgcbd69jone7b42hohig0884jnbpjbxn1ixwilkv-3msk9zj5fojh03psnfwq6yw97 \
172.31.0.15:2377
To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.

Criando e Ingressando novos Hosts ao Cluster

Agora vamos iniciar mais duas máquinas workers com o mesmo comando, só trocando a label. Trataremos a configuração delas no próximo passo.

Iniciando o Minion001 — Nosso primeiro Worker

$ docker-machine create -d amazonec2 --amazonec2-vpc-id vpc-ea72618c --amazonec2-subnet-id subnet-d8709bf4 --amazonec2-region us-east-1 --amazonec2-zone c --amazonec2-instance-type t2.micro  --amazonec2-security-group swarm-cluster minion001

Iniciando o Minion002 — Nosso segundo Worker

$ docker-machine create -d amazonec2 --amazonec2-vpc-id vpc-ea72618c --amazonec2-subnet-id subnet-d8709bf4 --amazonec2-region us-east-1 --amazonec2-zone c --amazonec2-instance-type t2.micro  --amazonec2-security-group swarm-cluster minion002

Esse processo vai fazer toda a configuração básica da máquina, inclusive instalar Docker e etc. Assim que todos os nosso nodes inciais estiverem prontos, podemos importar as variáveis de ambiente dos mesmos ou conectar neles via ssh com o docker-machine e rodar aquele comando que swarm init nos deu para ingressar novos hosts.

$ docker-machine ssh minion001...$ sudo docker swarm join \
--token SWMTKN-1-3ho1krpc5yirpyrush3psmjo7x9z8x3n3scy4gzkq9p8471phn-2bgn1fw9bpctz54jfbjsvtdzt \
172.31.0.15:2377

E no segundo host, o mesmo esquema:

$ docker-machine ssh minion002...sudo docker swarm join \
--token SWMTKN-1-3ho1krpc5yirpyrush3psmjo7x9z8x3n3scy4gzkq9p8471phn-2bgn1fw9bpctz54jfbjsvtdzt \
172.31.0.15:2377

Agora podemos listar todos os nosso nodes facilmente com o comando:

$ docker node ls

Assim como o primeiro exemplo, vamos fazer um deploy de um stack bacana que eu criei para testar o funcionamento de load balances em demo.

Link: https://github.com/msfidelis/docker-api-demo

Rodando o Deploy:

$ docker stack deploy -c docker-compose-prodswarm.yml app

O deploy default pede 4 containers durante o deploy, para verificar a distribuição dos mesmos, podemos executar o comando abaixo, onde app é o nome do deploy dos serviços que acabamos de criar.

$ docker stack ps app

Para testar a API, podemos pegar o IP do host master e acessar o Endpoint que nos mostra o hostname da máquina que está atendendo a requisição. Essa demonstração vai também nos provar que o load balance está acontecendo dentro do service da API. O correto é as requisições serem distribuídas entre todos os containers.

$ docker-machine ip minion001

Agora acesse várias vezes:

http://ip-do-minion/whoami

O Docker Swarm Visualizer é um projeto bem bacana que te mostra visualmente a distribuição atual de containers dentro dos seus nodes do cluster. Para fazer o deploy dele, vamos primeiro criar um serviço dentro do nosso manager

Link do Projeto: https://github.com/dockersamples/docker-swarm-visualizer

$ docker service create \
--name=viz \
--publish=8080:8080/tcp \
--constraint=node.role==manager \
--mount=type=bind,src=/var/run/docker.sock,dst=/var/run/docker.sock \
dockersamples/visualizer

Agora se acessarmos o ip externo do nosso manager na porta 8080 iremos nos deparar com essa Dashboard legal

Agora vamos escalar os containers dentro dos nosso nodes. Vamos escalar o service api dentro do da stack app em 10 containers.

$ docker service scale app_api=10

E temos o resultado na hora da distribuição efetuada dentro do nosso Visualizer do Cluster.

No próximo post iremos abordar a criação do mesmo cluster, porém utilizando o Amazon ECS e o Registry de Imagens. Fiquem ligados!

:)

Power Ranger Vermelho.