Implementando microsserviços com Kubernetes na prática

Twitter

Vinícius Campitelli

Preparação

Para acompanhar a palestra, siga os passos a seguir:

Clone esse repositório:


                                    $ git clone --recursive -b phpcs \
                                        [email protected]:vcampitelli/workshop-kubernetes.git

Acesse os slides abrindo docs/index.html em seu navegador
Instale o Docker em docs.docker.com/get-docker
Instale o minikube em minikube.sigs.k8s.io

Entre na pasta scripts e execute:


                                    $ minikube start

Microsserviços

A variant of the SOA structural style – arranges an application as a collection of loosely-coupled services. In a microservices architecture, services are fine-grained and the protocols are lightweight.

Wikipedia

Microsserviços

embarcados.com.br

Containers

Containers are an abstraction at the app layer that packages code and dependencies together. Multiple containers can run on the same machine and share the OS kernel with other containers, each running as isolated processes in user space. Containers take up less space than VMs (container images are typically tens of MBs in size), can handle more applications and require fewer VMs and Operating systems.

Docker

Containers

Docker

Kubernetes

Kubernetes, also known as K8s, is an open-source system for automating deployment, scaling, and management of containerized applications.

Kubernetes

Anunciado em 2014 pelo Google e mantido desde 2016 pela Cloud Native Computing Foundation , suporta diversos runtimes de execução de containers, como containerd, CRI-O e qualquer implementação do CRI

Kubernetes

C#Corner

Kubernetes

Pods

Pods are the smaller deployable units of computing that you can create and manage in Kubernetes.

Pod is a group of one or more containers, with shared storage and network resources, and a specification for how to run the containers. A Pod's contents are always co-located and co-scheduled, and run in a shared context.

Kubernetes

Deployment

A Deployment provides declarative updates for Pods and ReplicaSets.
You describe a desired state in a Deployment, and the Deployment Controller changes the actual state to the desired state at a controlled rate. You can define Deployments to create new ReplicaSets, or to remove existing Deployments and adopt all their resources with new Deployments.

Kubernetes

Service

An abstract way to expose an application running on a set of Pods as a network service.

In Kubernetes, a Service is an abstraction which defines a logical set of Pods and a policy by which to access them (sometimes this pattern is called a micro-service).

Kubernetes

Cluster

Conjunto de servidores de processamento, chamados nós, que executam aplicações containerizadas.

Todo cluster possui ao menos um servidor de processamento (worker node), que hospeda os Pods.

Em ambientes de produção, o ambiente de gerenciamento geralmente executa em múltiplos computadores e um cluster geralmente executa em múltiplos nós (nodes) , provendo tolerância a falhas e alta disponibilidade.

nginx.com/blog/what-is-a-service-mesh

Kubernetes

Hands-on

Kubernetes

Hands-on

Instalando o minikube

Siga a documentação oficial em minikube.sigs.k8s.io para instalar o minikube de acordo com seu sistema operacional

Para ambientes Linux com arquitetura amd64, os comandos são:


                            $ curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
                            $ sudo install minikube-linux-amd64 /usr/local/bin/minikube

Kubernetes

Hands-on

Iniciando o cluster

Clone ou atualize este repositório:


                            $ git clone --recursive -b phpcs \
                                [email protected]:vcampitelli/workshop-kubernetes.git

Entre na pasta scripts e inicialize o cluster com:


                            $ minikube start

Kubernetes

Hands-on

Deploy do cluster

O minikube cria um serviço separado do Docker, então sempre que iniciarmos um terminal e quisermos interagir diretamente com ele, devemos especificar que queremos executar os comandos nesse ambiente:


                            $ eval $(minikube -p minikube docker-env)

Kubernetes

Hands-on

Deploy do cluster

Execute os comandos abaixo para fazer o build das imagens do Docker:


                            $ docker build -t auth:0.0.1 auth
                            $ docker build -t posts:0.0.1 posts
                            $ docker build -t comments:0.0.1 comments
                            $ docker build -t composition:0.0.1 composition

Kubernetes

Hands-on

Deploy do cluster

Agora, vamos começar a configurar as nossas aplicações:


                            $ minikube kubectl -- create \
                                -f k8s/00-jwt.yml \
                                -f k8s/01-auth.yml \
                                -f k8s/01-posts.yml \
                                -f k8s/01-comments.yml \
                                -f k8s/01-composition.yml

Kubernetes

Hands-on

Deploy do cluster

Para acompanhar tudo que foi configurado:


                            $ minikube kubectl -- get pods,services,deployments

Kubernetes

Hands-on

Acessando os serviços

Como não há um serviço de Load Balancing no minikube, devemos expor os IPs dos serviços para eles serem acessados localmente

Execute o comando abaixo em um novo terminal e mantenha-o rodando:


                            $ minikube tunnel --cleanup

Kubernetes

Hands-on

Acessando os serviços

Volte ao terminal anterior, espere alguns segundos até que os três
EXTERNAL-IPs estejam alocados e execute o comando a seguir:


                            $ minikube kubectl -- get services
                            NAME                  TYPE           CLUSTER-IP       EXTERNAL-IP      PORT(S)          AGE
                            auth-service          LoadBalancer   10.106.141.164   <pending>        3000:32110/TCP   5m
                            comments-service      LoadBalancer   10.102.133.17    <pending>        3000:30921/TCP   5m
                            composition-service   LoadBalancer   10.99.218.84     <pending>        3000:32527/TCP   5m
                            kubernetes            ClusterIP      10.96.0.1        <none>           443/TCP          5m
                            posts-service         LoadBalancer   10.106.220.106   <pending>        3000:32532/TCP   5m

Kubernetes

Hands-on

Acessando os serviços

Volte ao terminal anterior, espere alguns segundos até que os três
EXTERNAL-IPs estejam alocados e execute o comando a seguir:


                            $ minikube kubectl -- get services
                            NAME                  TYPE           CLUSTER-IP       EXTERNAL-IP      PORT(S)          AGE
                            auth-service          LoadBalancer   10.106.141.164   10.106.141.164   3000:32110/TCP   5m
                            comments-service      LoadBalancer   10.102.133.17    10.102.133.17    3000:30921/TCP   5m
                            composition-service   LoadBalancer   10.99.218.84     10.99.218.84     3000:32527/TCP   5m
                            kubernetes            ClusterIP      10.96.0.1        <none>           443/TCP          5m
                            posts-service         LoadBalancer   10.106.220.106   10.106.220.106   3000:32532/TCP   5m

Kubernetes

Hands-on

Acessando os serviços

Para facilitar, vamos guardar os IPs com as portas em variáveis:


                            $ URL_AUTH=http://10.106.141.164:3000
                            $ URL_COMMENTS=http://10.102.133.17:3000
                            $ URL_COMPOSITION=http://10.99.218.84:3000
                            $ URL_POSTS=http://10.106.220.106:3000

Dica: você pode usar o script urls.sh para fazer isso automaticamente:


                            $ eval $(./urls.sh)

Kubernetes

Hands-on

Acessando os serviços

Para se autenticar na aplicação, execute o comando abaixo:


                            $ curl -X POST -u "admin:admin" "${URL_AUTH}/auth"

Resultado:


                            {
                              "access_token": "eyJhbGciOiJFUzI1NiJ9.eyJzY29wZXMiOlsidXNlcnMiLCJwb3N0cyIsImNvbW...",
                              "expiration": "..."
                            }

Kubernetes

Hands-on

Acessando os serviços

Salve o access_token em uma variável para facilitar as próximas chamadas:


                            $ TOKEN="eyJhbGciOiJFUzI1NiJ9.eyJzY29wZXMiOlsidXNlcnMiLCJwb3N0cyIsImNvbW..."

Dica: execute o script token.sh para fazer isso automaticamente:


                            $ eval $(./token.sh)

Teste os serviços:


                            $ curl -H "Authorization: Bearer ${TOKEN}" "${URL_POSTS}/posts"
                            $ curl -H "Authorization: Bearer ${TOKEN}" "${URL_COMMENTS}/comments"
                            $ curl -H "Authorization: Bearer ${TOKEN}" "${URL_COMPOSITION}"

Kubernetes

Hands-on

Configurando o Autoscaling

Ative o plugin de Metrics para coletar dados do uso de recursos:


                            $ minikube addons enable metrics-server

Abra um novo terminal e aplique a regra de Autoscaling:


                            $ minikube kubectl -- apply -f k8s/02-hpa.yml

kubernetes.io/docs/tasks

Kubernetes

Hands-on

Configurando o Autoscaling

Abra um novo terminal e execute o comando abaixo para acompanhar o status:


                            $ watch -n 1 "minikube kubectl -- get hpa"

Também é possível rodar este comando para visualizar o histórico de ações:


                            $ minikube kubectl -- describe hpa posts

Kubernetes

Hands-on

Configurando o Autoscaling

Baixe o wrk para realizar requisições simultâneas e execute:


                            $ wrk -t4 -c400 -d30s \
                                -H "Authorization: Bearer ${TOKEN}" \
                                "${URL_POSTS}/posts"

PS: esse comando irá abrir 400 conexões distribuídas em 4 threads durante 30 segundos.
Ajuste esses números para atender às especificações de sua máquina.

Service Mesh

É uma camada dedicada de infraestrutura para facilitar a comunicação entre serviços usando um proxy

Wikipedia

Service Mesh

Propõe uma gestão mais eficaz das comunicações entre serviços, maior controle operacional e também o fornecimento de informações comportamentais

Wikipedia

Service Mesh

Algumas funcionalidades

Encriptação;
Load balancing;
Observabilidade;
Rastreabilidade;
Circuit breaker;
Autenticação e autorização.

Service Mesh

Visão geral

Service Mesh

Visão geral

Sem Com Service Mesh

Service Mesh

Istio

Is an open source Service Mesh that layers transparently onto existing distributed applications

Service Mesh

Istio

Algumas funcionalidades

Comunicação segura entre serviços via TLS, autenticação e autorização
Balanceamento de carga automático para HTTP, gRPC, WebSocket e TCP
Controle de tráfego através de roteamento, retentativas, injeção de falhas, Circuit breaker, versionamento e mais
Observabilidade com coleta automática de métricas, logs e traces do tráfego

Service Mesh

Hands-on

Service Mesh

Hands-on

Instalando o Istio

Seguindo a documentação em istio.io:


                            $ curl -L https://istio.io/downloadIstio | sh -
                            $ cd istio-1.15.2
                            $ export PATH=$PWD/bin:$PATH

Isso irá adicionar a pasta istio-1.15.2/bin em seu $PATH temporariamente

Para fazer de forma permanente, você pode colocar o último comando (export ...) em algum arquivo de seu sistema que seja sempre carregado, como /etc/profile, ~/.bashrc, ~/.zshrc, entre outros

Service Mesh

Hands-on

Instalando o Istio

Adicione a label istio-injection=enabled no namespace default, indicando que queremos injetá-lo automaticamente em todos os recursos da nossa aplicação, e instale o perfil demo:


                            $ minikube kubectl -- label namespace default istio-injection=enabled
                            $ istioctl install --set profile=demo -y

Saiba mais sobre os outros perfis na documentação

Vamos apagar os pods existentes para que quando o Kubernetes suba novos, o Istio possa injetar seus proxies:


                            $ minikube kubectl -- delete pods -l app

Service Mesh

Hands-on

Criando o API Gateway

Vamos criar um API Gateway para fazer o roteamento dos nossos serviços:


                            $ minikube kubectl -- create -f k8s/03-gateway.yml

Service Mesh

Hands-on

Criando o API Gateway

Descubra o IP do istio-ingressgateway:


                            $ minikube kubectl -- get service istio-ingressgateway -n istio-system
                            NAME                   TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)                AGE
                            istio-ingressgateway   LoadBalancer   10.101.22.8      10.101.22.8   15021:32023/TCP, ...   1h

E mais uma vez, vamos salvar em uma variável para facilitar o uso:


                            $ URL_GATEWAY=http://10.101.22.8

Service Mesh

Hands-on

Criando o API Gateway

Vamos testar o roteamento:


                            $ curl -H "Authorization: Bearer ${TOKEN}" "${URL_GATEWAY}/posts"
                            $ curl -H "Authorization: Bearer ${TOKEN}" "${URL_GATEWAY}/comments"
                            $ curl -H "Authorization: Bearer ${TOKEN}" "${URL_GATEWAY}/composition"

Service Mesh

Hands-on

Retentativas automáticas e timeout

Abra um novo terminal para aplicar as regras e acompanhar os logs:


                            $ minikube kubectl -- apply -f k8s/04-retry.yml
                            $ minikube kubectl -- logs -f deployments/posts-deployment

Volte ao terminal anterior e faça consultas simulando falhas intermitentes:


                            $ curl -H "Authorization: Bearer ${TOKEN}" -H "X-Fail: 1" "${URL_GATEWAY}/posts"

Veja nos logs que o próprio Service Mesh refaz a consulta ao serviço

Service Mesh

Hands-on

Lançamento gradual de versões

Altere algo no sistema de postagens e gere uma nova versão do Docker e aplique as regras:


                            $ docker build -t posts:0.0.2 posts
                            $ minikube kubectl -- set image deployment/posts-deployment posts=posts:0.0.2
                            $ minikube kubectl -- apply -f k8s/05-shifting.yml

Faça requisições ao serviço e veja algumas indo para a nova versão:


                            $ curl -H "Authorization: Bearer ${TOKEN}" "${URL_GATEWAY}/posts"

Chaos Engineering

Conceito

Processo de testar um sistema para garantir que ele pode resistir a interrupções inesperadas

The best way to avoid failure is to fail constantly

Netflix

Chaos Engineering

Conceito

Quebrar um sistema com a proposta de coletar informações que vão ajudar a melhorar a resiliência do sistema

É uma abordagem de teste para software e garantia de qualidade, sendo adequado a sistemas distribuídos e processos modernos

Chaos Engineering

Conceito

Quanto maior e mais complexo o sistema, mais imprevisível e caótico será seu comportamento

Estes experimentos geram intencionalmente condições turbulentas em um sistema distribuído para testá-lo e encontrar suas fraquezas

Chaos Engineering

Objetivo

Identificar fraquezas em um sistema através de experimentos controlados, que introduzem comportamentos randômicos e imprevisíveis

Chaos Engineering

Resultados possíveis

Pontos cegos: Locais onde o software de monitoramento não pode coletar dados adequados
Bugs escondidos: Falhas e outros problemas que podem causar mal funcionamento do software
Gargalos de performance: Situações nas quais eficiência e performance poderiam ser melhoradas

bit.ly/vcampitelli-workshops

Chaos Engineering

Ferramentas

Simian Army ARQUIVADO: Coleção de ferramentas lançada pela Netflix para automatizar testes de caos
Chaos Monkey: Desativa instâncias aleatoriamente causando falhas no sistema
Kube Monkey: Versão do Chaos Monkey para Kubernetes
Gremlin: Funciona com AWS e Kubernetes e para os experimentos se detectar riscos
AWS Fault Injection Simulator: Serviço totalmente gerenciado também com proteções para evitar problemas

Chaos Engineering

Hands-on

Chaos Engineering

Hands-on

Abra um novo terminal para acompanhar os logs:


                            $ minikube kubectl -- logs -f service/istio-ingressgateway -n istio-system

Volte ao terminal anterior, aplique a regra para adicionar delay e abortar requisições aleatoriamente e teste os comentários:


                            $ minikube kubectl -- apply -f k8s/06-fault.yml
                            $ curl -H "Authorization: Bearer ${TOKEN}" "${URL_GATEWAY}/comments"

Nota: no Istio, não é possível injetar falha e utilizar retry / timeout no mesmo serviço (ver documentação)

Circuit Breaker

Conceito

Design pattern para criar microsserviços resilientes limitando o impacto de falhas e latências nos serviços

Um de seus objetivos básicos é lidar com falhas de forma graciosa para que não ocorram o cascateamento para outros serviços

Em um ambiente de microsserviços, falhar rapidamente é crítico

dzone.com

Circuit Breaker

Conceito

Circuit Breaker

Conceito

Circuit Breaker

Hands-on

Circuit Breaker

Hands-on

Aplique a regra que irá evitar que o serviço de composição fique lento por causa de falhas na postagem:


                            $ minikube kubectl -- apply -f k8s/07-circuit-breaker.yml
                            $ curl -H "X-Sleep-Fail: 1" -H "Authorization: Bearer ${TOKEN}" "${URL_GATEWAY}/composition"

Observabilidade

Conceito

Processo que usa ferramentas de software para detectar problemas, observando as entradas e saídas da pilha de tecnologia. As entradas incluem pilhas de aplicação e infraestrutura, enquanto as saídas incluem transações de negócios, experiências de usuário e desempenho de aplicações.

cisco.com

Observabilidade

Hands-on

Observabilidade

Hands-on

Instalando o Kiali (dashboard), Prometheus (métricas), Grafana (monitoramento) e Jaeger (tracing distribuído):


                            $ minikube kubectl -- create -f <caminho-para-o-istio>/samples/addons
                            serviceaccount/grafana configured
                            configmap/grafana configured
                            service/grafana configured
                            deployment.apps/grafana configured
                            ...

Para abrir o Kiali no navegador, execute o comando abaixo e acesse o endereço informado:


                            $ istioctl dashboard kiali
                            http://localhost:20001/kiali

Referências

Workshops de TI

Gostou? Então conheça meus treinamentos corporativos sobre Desenvolvimento, Segurança da Informação, DevOps, Arquitetura de Sistemas e diversos outros assuntos

Obrigado!

Slides & GitHub

Twitter