Implementando microsserviços com Kubernetes na prática

Vinícius Campitelli

Slides

Slides
viniciuscampitelli.com/workshop-kubernetes

Sobre mim

Sobre mim

Vinícius Campitelli
  • Membro do PHPSP
  • Entusiasta em cibersegurança
  • Desenvolvedor há 15 anos
  • Consultor e instrutor de treinamentos em TI
Vinícius Campitelli

Preparação

Preparação

Para acompanhar a palestra, siga os passos a seguir:

  1. Clone esse repositório:
    
                                        $ git clone --recursive -b phpcs \
                                            [email protected]:vcampitelli/workshop-kubernetes.git
                                    
  2. Acesse os slides abrindo docs/index.html em seu navegador
  3. Instale o Docker em docs.docker.com/get-docker
  4. Instale o minikube em minikube.sigs.k8s.io
  5. Entre na pasta scripts e execute:
    
                                        $ minikube start
                                    

Microsserviços

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

Arquitetura de microsserviços
embarcados.com.br

Containers

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

O que são containers Docker
Docker

Kubernetes

Kubernetes

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

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

Kubernetes

Arquitetura do 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.io

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

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

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.
kubernetes.io

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

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 nginx.com/blog/what-is-a-service-mesh

Service Mesh

Visão geral

Sem Com Service Mesh

Kubernetes
Kuber...
Sidecar
Proxy
Side...
Sidecar
Proxy
Side...
GET http://app2
GET http://app2
Aplicação 1
Aplica...
Aplicação 2
Aplica...
Aplicação 2
Aplica...
Usuário
Usuário
GET http://app1
GET http://app1

Service Mesh

Istio

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

Service Mesh

Istio

Algumas funcionalidades

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
                        
istio.io

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

istio.io

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"
                        
istio.io

Chaos Engineering

Chaos Engineering

Conceito

Processo de testar um sistema para garantir que ele pode resistir a interrupções inesperadas
Tech Target
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

Tech Target

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

Tech Target

Chaos Engineering

Objetivo

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

Tech Target

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

Tech Target

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

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

Disjuntor
diversitech.com

Circuit Breaker

Conceito

Circuit Breaker
banzaicloud.com

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

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
bit.ly/vcampitelli-workshops

Obrigado!