Docker Swarm :: Criando um cluster de EC2 na Amazon AWS com Docker Swarm.

Share:
Créditos: Farzad Nazifi



Mais um post migrado do Medium :)


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.

Veja mais: Docker Swarm :: Quickstart do seu Cluster Local com Docker-Machine e Virtualbox


Preparando a Amazon AWS

Vamos começar preparando toda a infra necessária manualmente no Console da AWS. Neste exemplo estaremos fazendo uso pesado de vários recursos da VPC. Então vamos começar configurando ela antes de qualquer coisa. 

1. Criando uma VPC

No console da AWS, acesse o painel do VPC. Em seguida vamos criar nossa primeira VPC
Clique em “Create VPC”. Dentro dele vamos criar uma VPC Simples com com um range de IP’s IPV4.
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-1 

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

  • Dentro do painel da VPC, vamos encontrar a opção Subnets e “Create Subnet”. 
  • Vamos atribuir um nome amigável que eu vou chamar de swarm-subnet e anexar a VPC do Swarm que acabamos de criar. 
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 

3. 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:
  • Ir no nosso painel de configurações da VPC e encontrar a opção “Internet Gateways”. 
  • Caso não exista um Default, clique em “Create Internet Gateway”. Coloque um nome amigável e em seguida 
  • 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.
  • No mesmo menu da VPC, procure pela opção Route Table
  • Procure pela Route Table do Swarm, vá até a aba Routes e clique em Edit
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.


4. 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:

  • Acessar o Console do IAM 
  • Acessar o Menu “Users” 
  • Clicar no Botão “Add User” 
  • 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.

5. Criando 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:
  • Entrar no painel de EC2 do Console da Amazon 
  • Ir até o menu Network & Security 
  • Clicar em Security Groups 
  • Create Security Group 



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! Coloque o tráfego de All TCP librado para a source do Security Group. Você irá encontrar o mesmo pelo id.

Criando os Nodes do Cluster.


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 o eval.

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


$ 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 


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


Fazendo um Deploy de Testes no Cluster


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


Testando nossa API


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

Bonus: Escalando Containers e monitorando com Docker Swarm Visualizer


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!

:)

Um comentário: