Este micro manual foi feito para você que quer saber rapidamente como colocar sua aplicação num cluster Kubernetes hosteado na Amazon. Como é um manual, e não um livro guia, não focarei em ter explicações profundas.

Observação: Como este tipo de tecnologia avança rápido, é possível que algumas coisas escritas nesse manual fiquem obsoleta em questão de meses (ou até mesmo semanas). Caso você ache que algo precisa ser atualizado, não hesite em alterar o manual via pull requests ou email.

Disclaimer: Este manual foi feito baseado em um manual similar em inglês de um coléga. Ele é apenas uma versão extendida e traduzida para Português do Brasil de informações colhidas na internet.

• Pré Requisitos
• Primeiros Passos
• Selecionando a instância baseado na disponibilidade de Pods desejada
• Crie seu cluster EKS na Amazon e os Nós Trabalhadores
• Deletando o cluster EKS via eksctl
• Dando Permissão a outros usuários
• Instalando a Interface de Usuário Kubernetes (Dashboard)
• Usando HELM em conjunto com AWS
• Tillerless Helm (Helm sem Tiller)
• Instalar Containers do Docker

Antes de começar o tutorial, assumo que você tenha uma conta na Amazon Web Services (AWS).

Caso não queira criar uma conta na AWS, você pode fazer a maioria das coisas explicadas nesse manual usando o Minikube.

Também é necessário que você possua pyhton3 instalado na sua máquina. Caso não possua, baixe aqui ou instale via apt-get our homebrew, etc...

A primeira parte deste tutorial irá guiá-lo na instalação das ferramentas necessárias para se concetar com a conta na amazon. É esperado que você já possua a conta no serviço AWS.

Em possessão de uma conta AWS, você precisa criar um token de segurança para faze a comunicação com a API.

1. Primeiramente instale o cliente na sua máquina.

   1. pip3 install awscli --upgrade --user
   2. Verifique a versão usando o comando: aws --version
   3. Se você não foi capaz de instalar a versão 1.16.156 ou mais recente, você precisa garantir que o AWS IAM Authenticator para Kubernetes está instalado no seu sitema. Para maiores informações, veja a documentação oficial

2. Configure seu cliente com as credenciais AWS CLI Credentials no seu ambiente:

   1. Execute o comando aws configure. Feito isto, o sistema irá pedir uma série de informações a serem preenchidas.
      1. AWS Access Key ID [None]: Coloque a sua account key id aqui
      2. AWS Secret Access Key [None]: Coloque seu Secret Access Key aqui
      3. Default region name [None]: Coloque a região que você deseja deploy o sistema aqui.
         1. Exemplo: Toquio é ap-northeast-1
         2. Clique aqui para ver as regiões
      4. Default output format [None]: json
   2. Instale a ferramenta eksctl
      1. curl --silent --location "https://github.com/weaveworks/eksctl/releases/download/latest_release/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp
      2. sudo mv /tmp/eksctl /usr/local/bin
      3. Rode eksctl version para ter certeza que tudo occorreu corretamente.
   3. Instale e configure o kubectl para amazon EKS (apenas para sistemas Unix-like)
      1. curl -LO https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl
      2. Dê permissão para o kubectl ser executável: chmod +x ./kubectl
      3. Mova a ferramenta para o seu PATH: sudo mv ./kubectl /usr/local/bin/kubectl
      4. Rode kubectl version para ter certeza que tudo occorreu corretamente.

Antes de criar o seu cluster, você precisa ter em mente a quantidade de pods que você deseja implantar no seu cluster. A conta para a quantidade de pods disponíveis por cluster é a seguinte:

instanceSupportedIPs = Número máximo de interfaces de rede (NI) suportadas pela instância;
instanceSupportedIPv4Address = Número de endereços IPv4 (ou IPv6) por interface de rede;
numeroMaximoPods = ( instanceSupportedIPs * instanceSupportedIPv4Address ) - 1;

Por exemplo, se você possui a instância t3.nano, que suporta o máximo de 2 interface de redes e possui 2 endereços IPv4 por interface, a sua disponibilidade de Pods será de 3. Isto devido ao fato de um endereço de IP ser reservado para o nó.

2 * 2 -1 = 3

A informação sobre a quantidade de Interfaces de Rede e a quantidade de endereços IPv4(6) por interface pode ser encontrada neste endereço.

Para descobrir a quantidade de Pods que estão rodando no seu cluster, execute o seguinte comando:

kubectl get pods --all-namespaces | grep -i running | wc -l

Caso, queira saber quais Pods estão rodando, simplesmente remova o wc -l do comando anterior.

Mais informações nesse blog post, ou no site oficial.

Existem diversas formas de criar clusters AWS, uma das mais comuns é via CLI (interface de linha de comando). Para isto você precisa ter instalado eksctl (caso ainda não tenha feito isso, veja como na seção de primeiros passos). Depois de ter decidido a instância que gostaria de instalar (caso esteja em dúvida, clique aqui), simplesmente execute o seguinte comando:

eksctl create cluster \
--name prod \
--version 1.12 \
--nodegroup-name standard-workers \
--node-type t3.medium \
--nodes 3 \
--nodes-min 1 \
--nodes-max 4 \
--node-ami auto

Para mais informações, visite o site com a documentação eksctl (em inglês).

Caso o seguinte erro apareça, siga as instruções neste guia para instalá-lo aqui:

neither aws-iam-authenticator nor heptio-authenticator-aws are installed

Testando:

kubectl get svc

Exemplo de saída:

NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
kubernetes   ClusterIP   10.100.0.1      <none>        443/TCP    21h

Para deletar o cluster, é necessário que sua versão eksctl seja superior a pelo menos a versão 0.1.31. Para verificar suav versão, execute o comando:

eksctl version

Caso, sua versão não seja compatível, você precisará atualizar seu eksctl. Para atualizar eksctl, consulte o guia oficial da amazon

1. Liste todos os serviços em execução no cluster

kubectl get svc --all-namespaces

2. Exclua todos os serviços que têm um valor EXTERNAL-IP associado. Esses serviços são liderados por um load balancer do Elastic Load Balancing, e você deve excluí-los no Kubernetes para permitir que o load balancer e os recursos associados sejam liberados corretamente.

kubectl delete svc nome-do-serviço

Aonde nome-do-serviço é o nome do seu serviço.

3. Exclua o cluster e seus nós de operador associados com o seguinte comando, substituindo o texto vermelho pelo nome do seu cluster.

eksctl delete cluster --name nome-do-cluster

Aonde nome-do-cluster é o nome do seu cluster.

Para mais informações, veja a documentação oficial

Esta parte do manual é para quem deseja dar permissão a outros usuários acessar o cluster.

Para dar permissão para um usuário acessar seu repositório como root, você precisará de três peças de informação:

1. rolearn: Para obtê-la, vá para aws-console -> EKS -> cluster
2. userarn: Para obtê-la, na máquina do usuário que você quer dar permissão, rode o comando aws sts get-caller-identity.
3. designated_user: O nome de usuário (username) que você quer adicionar.

Em possessão dessas informações, você precisa criar o seguinte arquivo aws-auth.yaml:

apiVersion: v1
kind: ConfigMap
metadata:
  name: aws-auth
  namespace: kube-system
data:
  mapRoles: |
    - rolearn: arn:aws:iam::11122223333:role/EKS-Worker-NodeInstanceRole-1I00GBC9U4U7B
      username: system:node:{{EC2PrivateDNSName}}
      groups:
        - system:bootstrappers
        - system:nodes
  mapUsers: |
    - userarn: arn:aws:iam::11122223333:user/designated_user
      username: designated_user
      groups:
        - system:masters

Feito isto, você precisa aplicá-lo no seu cluster. Simplesmente rode o seguinte comando:

kubectl apply -f aws-auth.yaml

Para informações mais detalhadas, veja a documentação oficial.

Em caráter educacional, vamos instalar uma aplicação de livro de convidados no cluster e logo após vamos deinstalá-lo. Estes comandos foram retirados deste guia.

Caso queira instalar com apenas uma linha de código, copie e cole isto no terminal:

kubectl apply -f https://raw.githubusercontent.com/kubernetes/examples/master/guestbook-go/redis-master-controller.json && kubectl apply -f https://raw.githubusercontent.com/kubernetes/examples/master/guestbook-go/redis-master-service.json && kubectl apply -f https://raw.githubusercontent.com/kubernetes/examples/master/guestbook-go/redis-slave-controller.json && kubectl rolling-update redis-slave --image=k8s.gcr.io/redis-slave:v2 --image-pull-policy=Always && kubectl apply -f https://raw.githubusercontent.com/kubernetes/examples/master/guestbook-go/redis-slave-service.json && kubectl apply -f https://raw.githubusercontent.com/kubernetes/examples/master/guestbook-go/guestbook-controller.json && kubectl apply -f https://raw.githubusercontent.com/kubernetes/examples/master/guestbook-go/guestbook-service.json && kubectl get services -o wide --watch

Após a instalação completa do serviço e suas dependências, você pode acessar a aplicação pelo endereço externo do cluster (External IP). Para acessar o mesmo, execute o seguinte comando.

kubectl get services -o wide

Quando o endereço IP externo estiver disponível, aponte um navegador da web para esse endereço na porta 3000 para visualizar seu livro de convidados.

Por exemplo, http://a7a95c2b9e69711e7b1a3022fdcfdf2e-1985673473.us-west-2.elb.amazonaws.com:3000

Para desinstalar, basta remover todos os serviços criados anteriormente. Para isto, execute o seguinte comando:

kubectl delete rc/redis-master rc/redis-slave rc/guestbook svc/redis-master svc/redis-slave svc/guestbook

A Interface de Usuário permite que você visualize várias informações sobre o cluster. Informações como a quantidade de pods, serviços e etc são fácilmente visualizaveis usando essa ferramenta.

Para instalar no cluster, execute o seguinte comando:

kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v1.10.1/src/deploy/recommended/kubernetes-dashboard.yaml && kubectl apply -f https://raw.githubusercontent.com/kubernetes/heapster/master/deploy/kube-config/influxdb/heapster.yaml && kubectl apply -f https://raw.githubusercontent.com/kubernetes/heapster/master/deploy/kube-config/influxdb/influxdb.yaml && kubectl apply -f https://raw.githubusercontent.com/kubernetes/heapster/master/deploy/kube-config/rbac/heapster-rbac.yaml

Feito isso, crie um arquivo chamado eks-admin-service-account.yaml com as definições do serivço da conta, assim um role-binding cluster chamado eks-admin. Para criar o arquivo automáticamente, execute o seguinte código:

echo $'apiVersion: v1\nkind: ServiceAccount\nmetadata:\n  name: eks-admin\n  namespace: kube-system\n---\napiVersion: rbac.authorization.k8s.io/v1beta1\nkind: ClusterRoleBinding\nmetadata:\n  name: eks-admin\nroleRef:\n  apiGroup: rbac.authorization.k8s.io\n  kind: ClusterRole\n  name: cluster-admin\nsubjects:\n- kind: ServiceAccount\n  name: eks-admin\n  namespace: kube-system' > eks-admin-service-account.yaml

Após a criação do serviço e a cluster role binding. Está na hora de aplicá-lo ao seu cluster:

kubectl apply -f eks-admin-service-account.yaml

Nesta seção iremos mostrar como fazer o proxy do painel de control instalado no cluster, e como efetuar login utilizando um token.

Para efetuar login no seu painel de controle, você necessitará de um token. Para obter este token você precisa executar o seguinte comando:

kubectl -n kube-system describe secret $(kubectl -n kube-system get secret | grep eks-admin | awk '{print $1}')

Copie o token que será impresso no terminal (Não copie tudo, apenas o token).

Para iniciar o proxy, execute o seguinte comando:

kubectl proxy

Feito isso, seu computador deve estar conectado com o cluster, basta agora apenas acessar o painel de controle no browser. Clique Aqui para abrir o painel de controle.

Obs.: Você necessita do token obtido no passo anterior para logar.

Esta seção foi inspirada pelo guia oficial

Quando se trata de Kubernetes, uma ferramenta que é muito útil é o Helm. Helm introduz o conceito de charts, que são uma composição de recursos Kubernetes. Helm usa templates Go, o que permitem uma grande flexibilidade nos seus deploys, visto que é possível customizar valores do chart antes da instalaçãod o mesmo.

Helm possui dois componentes principais: o cliente de terminal e um servidor chamado Tiller.

A instalação do cliente é bem simples.

O pacote Snap de Helm é mantido por Snapcrafters

sudo snap install helm --classic

Para MacOS, pode-se instalar via Homebrew.

brew install kubernetes-helm

Os membros da comunidade Kubernetes contribuiram com uma build de um pacote para o Chocolatey. Normalmente este pacote está atualizado.

choco install kubernetes-helm

O pacote binário também pode ser instalado via scoop.

scoop install helm

O servidor Helm (Tiller) pode ser instalado no cluster facilmente rodando o seguinte comando no cliente helm:

helm init

Porém, esta opção é insegura visto que isso instala um servidor no seu cluster com acesso a todos os seus recursos. Se você deseja aumentar a segurança, isso envolve mais tarefas em relação ao gerenciamento de namespaces, certificados TLS e RBAC.

Uma das maiores preocupações em relação ao Tiller é que ele não é uma opção muito segura visto que ele reside dentro do cluster com todos os direitos adminstrativos. Visto que isto traz um grande risco para o cluster, existe muita discussão sobre a criação de alternativas para termos Helm, sem ter Tiller instalado no servidor. O termo em inglês para isto é Tillerless Helm (do inglês Helm sem Tiller).

Para usar o Helm sem Tiller, você pode instalar o plugin criado por Rimas Mocevicius

Para instalar simplesmente execute:

helm plugin install https://github.com/rimusz/helm-tiller

Para iniciar o Tiller localmente, execute o comando para iniciar com a flag `--client-only``.

helm init --client only

Aqui está uma lista de comandos básicos para Helm:

1. Iniciar Tiller com um namespace

helm tiller start my-tiller-namespace

2. Instalar um Chart para teste

helm tiller run my-tiller-namespace -- helm repo update
helm tiller run my-tiller-namespace -- helm install stable/mysql

3. Confirmar se o Chart foi instalado

kubectl get deployments

4. Parar o Tiller local, assim como seus plugins

helm tiller stop

É importante notar que para rodar comandos helm em um anmespace, você usa o comando helm tiller run my-tiller-namespace acompanhado do comando que deseja executar:

Exemplo:

helm tiller run my-tiller-namespace -- helm list
helm tiller run my-tiller-namespace --bash -c 'echo running helm; helm list'

Fonte para esta parte: Medium

O servidor de métricas é um agregador de dados de uso de recursos no cluster, e não é implantado por padrão em clusters do Amazon EKS. Fonte

Antes de prosseguir para a instalação, tenha certeza de ter as seguintes ferramentas instaladas:

1. curl: Para verificar se está instalado, execute o comando: curl --version
2. tar: Para verificar se está instalado, execute o comando: tar --version
3. gzip: Para verificar se está instalado, execute o comando: gzip --version
4. jq: Para verificar se está instalado, execute o comando: jq --version

Navegue até o diretório que você deseja que o servidor seja baixado e execute o seguinte comando:

mkdir servidor-metricas && cd servidor-metricas

Agora, baixe e instale o servidor de métricas no cluster

DOWNLOAD_URL=$(curl --silent "https://api.github.com/repos/kubernetes-incubator/metrics-server/releases/latest" | jq -r .tarball_url)
DOWNLOAD_VERSION=$(grep -o '[^/v]*$' <<< $DOWNLOAD_URL)
curl -Ls $DOWNLOAD_URL -o metrics-server-$DOWNLOAD_VERSION.tar.gz
mkdir metrics-server-$DOWNLOAD_VERSION
tar -xzf metrics-server-$DOWNLOAD_VERSION.tar.gz --directory metrics-server-$DOWNLOAD_VERSION --strip-components 1
kubectl apply -f metrics-server-$DOWNLOAD_VERSION/deploy/1.8+/

Verifique se o servidor de métricas foi instalado e está sendo executado no cluster com o seguinte comando:

kubectl get deployment metrics-server -n kube-system

Troque o $DOWNLOAD_VERSION pela versão do diretório ao qual você baixou o servidor.

kubectl delete -f metrics-server-$DOWNLOAD_VERSION/deploy/1.8+/

⚠️Importante!

Antes de iniciar a instalação, você precisa iniciar o Helm com o Tillerless plugin:

kubectl create namespace prometheus

helm tiller run my-tiller-namespace -- helm install stable/prometheus \
--name prometheus \
--namespace prometheus \
--set alertmanager.persistentVolume.storageClass="gp2",server.persistentVolume.storageClass="gp2"

Verifique se todos os pods no namespace prometheus estão prontos (READY state):

kubectl get pods -n prometheus

Use então kubectl para fazer o encaminhamento de porta do Console Prometheus para a sua máquina local:

kubectl --namespace=prometheus port-forward deploy/prometheus-server 9090

Se seus passos não geraram nenhum erro, você pode abrir o Console Prometheus no seu navegador padrão: localhost:9090

Para remover o Prometheus, você só precisa executar o comando usando seu namespace do tiller:

helm tiller run my-tiller-namespace -- helm delete prometheus && kubectl delete namespace prometheus

Até agora focamos em configuração do Kubernetes, sem mencionar como fazer para transformar nossos containers docker em Pods. De agora em diante atacaremos este problema:

Para fazer deploy dos containers docker em um cluster EKS, você primeiro precisa criar um repositório no Amazon Elastic Container Registry (ECR). Você pode conferir o guia oficial neste site.

Para criar o repositório com o nome hello-repository na região ap-northeast-1, execute o seguinte comando:

aws ecr create-repository --repository-name hello-repository --region ap-northeast1

Saída (Note a Uri do repositório (repositoryUri) na saída. Este será utilizado para fazermos push de Containers Docker):

{
    "repository": {
        "registryId": "aws_account_id",
        "repositoryName": "hello-repository",
        "repositoryArn": "arn:aws:ecr:region:aws_account_id:repository/hello-repository",
        "createdAt": 1505337806.0,
        "repositoryUri": "aws_account_id.dkr.ecr.region.amazonaws.com/hello-repository"
    }
}

Você precisa colocar a Tag na docker-image com o valor do repositoryUri:

Exemplo:

docker-image = hello-world

repositoryUri = aws_account_id.dkr.ecr.region.amazonaws.com/hello-repository

docker tag hello-world aws_account_id.dkr.ecr.region.amazonaws.com/hello-repository

Execute o comando aws ecr get-login --no-include-email para obter o comando de login de autenticação para o seu registro.

Troque o campo region para a região do repositório docker.

aws ecr get-login --no-include-email --region region

Rode o comando de login docker que foi retornado no passo anterior. Este comando provê um token de autorização com validade de 12 horas.

Envie (Push) a imagem para o Amazon ECR com o valor do repositoryUri do passo anterior.

Exemplo:

Troque aws_account_id.dkr.ecr.region.amazonaws.com/hello-repository pelo seu repositório docker.

docker push aws_account_id.dkr.ecr.region.amazonaws.com/hello-repository