Containers e K8s¶

Objetivos

1. Entender os conceitos básicos sobre Contêineres e seus Orquestradores.
2. Instalar o Octavia no Openstack
3. Integrar o Openstack e o Kubernetes

Pré-requisitos:

1. Terminar o capítulo anterior (SLA,DR e IaC)
2. Realizar a leitura sobre o Docker.
3. Realizar a leitura sobre o Kubernetes.
4. Realizar a leitura do Octavia. documentação e implantação
5. Realizar a leitura do Barbican.
6. Realizar a leitura dos Charms. Vault, Octavia, Barbican.

Voce chegou a um roteiro avancado, este Roteiro envolve a resolução de problemas de implantação, esperamos que você esteja preparado, este roteiro é prototipado por você!!!!¶

TARGET¶

DO INICIO DO ROTEIRO 1 ATE ONDE CHEGAMOS NO FIM DESTE ROTEIRO¶

Tipo de implantacoes¶

Tradicional¶

Inicialmente, as organizações executavam aplicativos em servidores físicos. Os limites de recursos não podem ser definidos para aplicativos em servidores físicos, o que causa problemas de alocação de recursos. Por exemplo, se vários aplicativos estiverem sendo executados em um servidor físico, pode haver uma situação em que um aplicativo consuma mais recursos, resultando em um desempenho insatisfatório de outros aplicativos. A solução para isso é executar cada aplicativo em um servidor físico diferente. Mas isso não aumentou porque os recursos são subutilizados e é caro para as organizações manter muitos servidores físicos.

Virtualizada¶

Como solução, a virtualização foi introduzida. Ele permite que você execute várias máquinas virtuais (VMs) na CPU de um único servidor físico. A virtualização permite que os aplicativos sejam isolados entre VMs e fornece um nível de segurança que as informações de um aplicativo não podem ser acessadas livremente por outro aplicativo. A virtualização permite uma melhor utilização dos recursos em servidores físicos e uma melhor escalabilidade, pois os aplicativos podem ser facilmente adicionados ou atualizados, os custos de hardware são reduzidos e muito mais. Com a virtualização, você pode apresentar um conjunto de recursos físicos como um cluster de máquinas virtuais descartáveis. Cada VM é uma máquina completa, executando todos os componentes, incluindo seu próprio sistema operacional, sobre hardware virtualizado.

Conteinerizada¶

Os contêineres são pacotes leves do código do seu aplicativo, juntamente com dependências, como versões específicas de tempos de execução de linguagem de programação e bibliotecas necessárias para executar seus serviços de software. Os contêineres facilitam o compartilhamento de recursos de CPU, memória, armazenamento e rede no nível dos sistemas operacionais e oferecem um mecanismo de empacotamento lógico no qual os aplicativos podem ser abstraídos do ambiente em que realmente são executados.

Os contêineres virtualizam no nível do sistema operacional enquanto as VMs virtualizam no nível do hardware

Instalando e Configurando o Octavia (Loadbalancer para Openstack)¶

• No servidor Main - análise o juju status seu LoadBalancer deve ser implantado nesta infraestrutura sem causar degradação dos serviços já existentes: Faça a instalação do Octavia de acordo com a leitura prévia obrigatória !!!

Ainda no Servidor main, vamos aumentar alguns limites:

openstack quota set --cores 100 [ID do Projeto]

openstack quota set --instances 100 [ID do Projeto]

No capítulo 3, foi realizada a implantação do Openstack no hardware disponível. Além de VMs, o Openstack consegue também manipular containers, tal qual o MaaS e o Juju. Contudo o grande problema é que não basta apenas criar e destruir um container, é preciso administrar uma complexa arquitetura, monitorando e controlando um conjunto de containers que representam uma implantação de um sistema.

WebServer¶

• Criar uma instância m1.small com IP público no Openstack, nomea-la como juju-openstack-web-server
• Adicionar um Security Group novo a esta instancia (não utilizar o default)
• Acessar a instancia criada
• Vamos criar um WebServer em NodeJS
• Criar o arquivo ~/hello-node/server.js

#!/usr/bin/env nodejs

var http = require('http');
var os = require('os');

var handleRequest = function(request, response) {
    console.log('Received request for URL: ' + request.url);
    response.writeHead(200);
    response.end('{ "host": ' + os.hostname() + ', "message": "Hello World!"}');
};

var www = http.createServer(handleRequest);
www.listen(8080);
console.log('Server running at http://localhost:8080/');

• Testar o WebServer rodando localmente no terminal.

sudo apt install nodejs
./server.js

Instalar o Docker na instancia¶

Arquitetura Docker

sudo apt-get update
sudo apt install build-essential apt-transport-https curl
curl -fsSL https://get.docker.com | sh -
sudo usermod -aG docker $USER
newgrp docker
docker version
docker run hello-world

• Criar uma um arquivo ~/hello-node/Dockerfile que dará origem ao container

FROM node:6.9.2
EXPOSE 8080
COPY server.js .
CMD node server.js

• Montar a imagem local (Cria um container com esta aplicacao webserver)

docker build -t hello-node:v1 ./hello-node/

• Rodar o container com a imagem criada.

docker container run hello-node:v1

Docker Hub¶

• Caso não tenha ainda, criar individualmente um login (usuário) na https://hub.docker.com/

• Fazer o login no Docker • Aplicar a tag na imagem e dar o push do Docker Hub • Para mais detalhes docker --help

Kubernetes aka k8s - iremos implatantar um conjunto de ferramentas e softwares que juntos forma o Kubernertes.¶

• Para facilitar o deploy do Kubernetes vamos utilizar uma "velha conhecida".

Deja-vu (Juju Reborn)¶

O Dashboard do Openstack possui alguns termos (region, instance type, security group, etc) que são semelhantes ao da AWS. Como visto anteriormente, Juju consegue operar sobre Public Cloud, Private Cloud, Bare-metal e Container. Para o setup ficar completo, agora vamos utilizar o Juju sobre o Openstack.

• Acesse a instância m1.tiny criada no início do roteiro.
• Fazer a instalação do Juju.
• Adicione o Openstack como Cloud Provider no Juju.
• Fazer o deploy do Kubernetes-core

• Instalar kubectl no cliente via snap. sudo snap install kubectl --classic

• Verificar a configuração do Kubernetes via kubectl kubectl cluster-info

• Caso tenha problemas ver: documentacao-kubernetes

• Configurar o kubectl proxy para utilização externa na porta 8080.
• Acessar o Dashboard.

Fazendo um Deploy¶

• Fazer o deploy da imagem docker criada na sessão anterior

kubectl run hello-node --image=[user]/hello-node:v1 --port=8080

• Verificar no terminal: kubectl get all
• Verificar o deploy status no Dashboard
• Expandir o deploy para 5 réplicas do pod

Acessando o Deploy - entregando a aplicação para seu cliente¶

Criar um serviço que irá expor o deploy

Alternativa I - ClusterIP com Ingress¶

kubectl expose deployment hello-node --type=ClusterIP

• Criar o arquivo ingress.yaml

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: hello-node-ingress
spec:
  rules:
  - host: hello-node.[ip do kubernetes-worker].xip.io
    http:
      paths:
      - path: /
        backend:
          serviceName: hello-node
          servicePort: 8080

kubectl create -f ingress.yaml

Alternativa II - NodePort¶

kubectl expose deployment hello-node --type=NodePort

• Verificar qual porta foi designada e liberar o security group do worker

juju run --unit kubernetes-worker/[# worker] "open-port [porta]"

Alterando o deploy¶

• Alterar o arquivo server.js
• Montar uma nova imagem com tag v2 e faça um push
• Fazer um deploy de um pod de testes
• Testar as alterações
• Fazer a implantação imediata em produção:

kubectl set image deployment/hello-node hello-node=[user]/hello-node:v2

Dinâmica Final: Utilizando o Load Balancer Octavia para o Serviço em Kubernetes¶

Objetivo¶

Distribuir o tráfego de entrada entre as réplicas do serviço hello-node em Kubernetes, utilizando o load balancer Octavia para assegurar que o tráfego seja balanceado e que o serviço esteja disponível mesmo que alguma réplica falhe.

Pré-requisitos¶

• Cluster Kubernetes em execução, com o serviço hello-node rodando com 5 réplicas.
• Configuração e validação do Octavia como load balancer no OpenStack, com certificados SSL ativos.
• Acesso à instância com Kubernetes para rodar os comandos.

Passos¶

1. Configuração do Serviço para o Load Balancer

2. Altere o tipo de exposição do serviço hello-node no Kubernetes para LoadBalancer. Esse tipo permite que o Kubernetes provisione automaticamente um balanceador de carga com Octavia, redirecionando o tráfego para as réplicas do serviço.

3. No arquivo de configuração do serviço, modifique a seção type para:

   apiVersion: v1
   kind: Service
   metadata:
     name: hello-node
     labels:
       app: hello-node
   spec:
     type: LoadBalancer
     ports:
     - port: 8080
       targetPort: 8080
     selector:
       app: hello-node
   

4. Aplicação do Serviço

5. Aplique a configuração atualizada com o comando:

   kubectl apply -f hello-node-service.yaml
   

6. Validação do Load Balancer

7. Verifique se o load balancer foi criado e se está direcionando o tráfego para as réplicas do serviço. Isso pode ser feito com o comando:

   kubectl get svc hello-node
   

8. Este comando mostrará o endereço IP externo atribuído pelo load balancer ao serviço hello-node. Anote esse IP, pois ele será utilizado para acessar o serviço.

9. Teste do Balanceamento de Carga

10. No navegador ou com curl, acesse o IP externo do load balancer para validar o balanceamento:

    curl http://[external-ip]:8080
    

11. Execute esse comando várias vezes ou atualize o navegador para observar como o load balancer distribui as requisições entre as réplicas. Você deve notar que as respostas vêm de diferentes réplicas do hello-node, indicando que o balanceamento está funcionando.

Reflexão¶

Essa dinâmica mostra como o load balancer Octavia integra-se ao Kubernetes para distribuir o tráfego automaticamente, suportando o serviço hello-node e garantindo alta disponibilidade. Após concluir essa etapa, você terá implantado um serviço com balanceamento de carga, aplicando as boas práticas de exposição e resiliência de sistemas distribuídos.

Conclusão: SOMENTE PARA PENSAR ¶

Você desempenhou uma implantação em tempo real usando Kubernetes e DockerHub. Como seria uma arquitetura de Continuous Integration/Continuous Delivery (CI/CD) real utilizando Kubernetes?