7.2 Configurando o ambiente local de desenvolvimento
A configuração do ambiente visa permitir ao desenvolvedor executar localmente a aplicação em um cluster na sua própria máquina, bem como possibilitar que seja realizado o deploy em uma nuvem pública utilizando os mesmos arquivos para a definição dos recursos.
Com isso, obtém-se um ambiente local que é muito mais próximo ao ambiente de produção, diminuindo as chances de ocorrerem erros devido às diferenças entre os ambientes, que poderiam ocorrer, por exemplo, ao utilizar o Docker Compose localmente e o Kubernetes no ambiente de produção.
Serão utilizadas diversas ferramentas como kubectl, k0s, Skaffold e Helm e Terraform, as quais terão suas funcionalidades apresentadas e discutidas. A seguir é apresentado o modo de configurar o ambiente local, utilizando as plataformas Linux e Windows.
Linux Ubuntu
Instalação do k0s
A primeira ferramenta que vamos instalar é o k0s , o qual permite que criemos um cluster localmente na nossa máquina para testarmos nossa aplicação. Ele também será utilizado para criar o cluster que será utilizado no ambiente de produção. Ele pode ser instalado com o seguinte comando:
curl -sSLf https://get.k0s.sh | sudo shPodemos então instalar um serviço que permitirá a criação de um cluster (com uma única máquina) com o seguinte comando (será necessário digitar sua senha para entrar no modo de super usuário):
sudo k0s install controller --singleUma vez instalado o serviço, devemos executá-lo (após esse passo, o serviço executará automaticamente sempre que a máquina for reiniciada):
sudo k0s startApós um ou dois minutos, o cluster estará funcional. Para verificar o status do serviço, pode-se utilizar o seguinte comando:
sudo k0s statusA resposta deverá ser semelhante a essa:
Version: v0.11.0
Process ID: 436
Parent Process ID: 1
Role: controller+worker
Init System: linux-systemdInstalação do kubectl
A ferramenta de linha de comando kubectl permite a execução de comandos para interação com o cluster criado. Essa ferramenta é bem interessante, pois permite, por exemplo, a utilização de seus comandos em scripts de automatização. É possível utilizar a versão que vem disponível com o próprio k0s, do seguinte modo:
Onde COMANDO_DO_KUBECTL deve ser substituído por algum comando específico do kubect. Por exemplo, podemos ver os nós do cluster desse modo:
No entanto, também é possível instalar uma versão arbitrária do kubectl usando um repositório. Esse modo é recomendável, pois assim é possível ter um controle maior sobre sua versão e suas atualizações.
O primeiro passo é atualizar o índice de pacotes do Ubuntu e instalar as dependências necessárias:
Na sequencia, deve ser baixada a chave GPG do repositório:
Deve-se adicionar o repositório ao índice de pacotes do Ubuntu:
Atualizar o índice e por fim instalar o kubect:
Desse modo, o kubectl poderá ser executado assim:
Porém será necessário executar os passos da próxima seção.
Configurando o kubectl para acessar o cluster do k0s
Se você instalou o kubectl em vez de usar o kubectl do k0s, necessitará executar os seguintes passos. É necessário criar um arquivo de configuração do kubectl, chamado config. O k0s tem u comando que cria essa configuração, e deve ser utilizado do seguinte modo:
sudo k0s kubeconfig create --groups "system:masters" NOME_USUARIO > k0s.config
Devemos substituir o NOME_USUARIO por um nome arbitrário, que será o nome do usuário que vamos utilizar para a acessar o cluster, por meio do kubectl.
Na sequencia, vamos criar o usuário no cluster, com a permissão de administrador, do seguinte modo (não se esqueça de substituir novamente o NOME_DO_USUARIO pelo nome definido no comando anterior) e jogar a saída para o arquivo k0s.config:
Será gerado um arquivo semelhante a esse:
Devemos agora mover esse arquivo para o diretório padrão de configuração do kubectl:
mv k0s.config $HOME/.kube/config
No arquivo gerado, na linha 12, temos a configuração current-context: k0s, que informa ao kubectl qual o contexto deve ser usado. Essa informação é interessante, pois podemos definir no arquivo diferentes contextos, e permitir a conexão a diferentes clusters Kubernetes. Também é possível definir o contexto atual usando a linha de comando:
kubectl config use-context k0s
Para verificar qual o contexto está sendo utilizado atualmente, é possível usar o seguinte comando:
kubectl config current-context
Instalação do Registry do Docker
Vamos precisar configurar um registry de imagens Docker. Nele, as imagens geradas pela nossa aplicação será armazenadas, e posteriormente acessadas pelo Kubernetes para a criação dos nossos containers.
Um único comando para o Docker inicializa o registry, na porta 5005:
docker run -d -p 5005:5000 --restart=always --name registry registry:2
A seguir, devemos alterar o nosso arquivo /etc/hosts, para criar um alias para o registry. Desse modo, vamos poder acessá-lo pela url http://registry-local:5005. Para isso, devemos editar o arquivo /etc/hosts e buscar a linha que contenha esse conteúdo:
127.0.1.1 nome-da-maquina
Ela é uma das primeiras linhas desse arquivo. Vamos alterá-la para acrescentar o alias do registry:
127.0.1.1 nome-da-maquina registry-local
Basta salvar o arquivo, para terminar a definição do alias. Para testar se está tudo correto, podemos utilizar o curl:
curl registry-local:5005/v2/
A resposta deve ser {}.
Por esse registry e o cluster rodarem localmente na nossa máquina, não precisamos definir um acesso seguro a ele, utilizando certificados SSL. No entanto, teremos que realizar algumas configurações no k0s para que o cluster Kubernetes possa acessar esse registry de maneira insegura. Para isso, vamos gerar um arquivo de configuração utilizado pelo k0s:
sudo containerd config default > containerd.toml
Devemos editar o arquivo containerd.toml gerado, e alterar as seguintes linhas:
root = "/var/lib/containerd" state = "/run/containerd"
Para que fiquem assim:
root = "/var/lib/k0s/containerd" state = "/var/lib/k0s/run/containerd"
Já a linha:
Deverá ficar assim:
Por último, logo abaixo da linha:
Vamos acrescentar o seguinte trecho:
De modo que essa parte do arquivo fique assim:
Lembre-se de manter a identação correta para que não haja problemas. Após essas alterações, vamos copiar esse arquivo para o diretório que o k0s usa para ler suas configurações:
Agora é necessário reiniciar o k0s com os dois comandos abaixo para que a alteração entre em vigor:
Para checar se não houve nenhum problema, execute o comando a seguir:
A saída deverá indicar que o serviço está ativo:
Agora que já estão corretos o cluster, o registry, e a comunicação entre eles, vamos instalar o Skaffold.
Instalação do Skaffold
O Skaffold é uma ferramenta que automatiza os processos de:
Geração de imagem
Envio da imagem para um registry
Deploy da aplicação no cluster Kubernetes
Com isso, o desenvolvedor consegue ficar focado somente no desenvolvimento da aplicação. Utilizaremos ele para realizar o deploy da aplicação tanto no cluster local, quanto no cluster do ambiente de produção. A sua instalação é bem simples e pode ser realizada com o seguinte comando, o qual instala a versão mais nova:
curl -Lo skaffold https://storage.googleapis.com/skaffold/releases/latest/skaffold-linux-amd64 && sudo install skaffold /usr/local/bin/
Para verificar a versão instalada, é possível utilizar o comando skaffold version, que deverá retornar algo semelhante a:
v1.25.0
Vamos agora definir que o repositório padrão de imagens, ou seja, o registry que será utilizado para enviar e obter imagens Docker, será o registry que instalamos:
Para confirmar que as configurações foram aplicadas com sucesso, execute o seguinte comando:
A saída dele deve ser semelhante a:
Uma vez configurado o Skaffold, podemos finalmente utilizá-lo.
Instalação do Helm
O Helm é uma ferramenta que gerencia pacotes do Kubernetes, e vai permitir que criemos uma pacote, denominado chart para distribuir, instalar e atualizar nossa aplicação em um cluster Kubernetes.
O Skaffold consegue utilizar o Helm para instalar a nossa aplicação no cluster, e com a utilização do Helm podemos ter diferentes configurações de acordo com o ambiente no qual vamos realizar o deploy da aplicação. Desse modo, por exemplo, podemos controlar o endereço no qual a aplicação vai estar disponível, a quantidade de memória e processamento que ela vai poder utilizar, entre outras configurações que podem variar de um ambiente para outro.
A instalação do Helm é bem simples no Linux, bastando executar os comandos a seguir:
Para verificar a versão instalada, execute:
Instalação do Terraform
O Terraform é uma aplicação que permite codificar a infraestrutura necessária para executar a aplicação como código, o qual pode ser armazenado e versionado em repositórios de código, tais como GitHub e GitLab.
Ao transformar a infraestrutura em código versionado, é possível ter um histórico atualizado das alterações promovidas na infraestrutura, e eventualmente reverter de modo simplificado as alterações realizadas, caso ocorra algum problema.
Para instalar o Terraform é necessário adidiconar a chave GPG do repositório:
Na sequencia deve ser adicionado o repositório do Terraform:
E por último atualizar o repositório e instalar a ferramenta:
Para conferir a versão instalada use o seguinte comando:
Após a configuração do ambiente local de desenvolvimento, vamos entender os recursos do Kubernetes que utilizaremos para realizar o deploy da aplicação na próxima seção.
Last updated
Was this helpful?