1. Blog
  2. Tecnologia
  3. Kubernetes: como configurar um playground local do K8S usando o WSL

Tecnologia

Kubernetes: como configurar um playground local do K8S usando o WSL

Por: Pablo Tondolo De Vargas

9 minutos de leitura

Atualmente, o Kubernetes (K8S) é a plataforma mais popular de orquestração e gerenciamento de contêineres. Ele nos permite gerenciar e escalonar mais facilmente nossas aplicações. No entanto, muitas vezes aprender a usar o K8S é um tanto quanto desafiador, especialmente quando estamos iniciando. É aqui que um playground local se torna importante para que possamos executar comandos sem receio do impacto que irá gerar.

Ter um playground local para o K8S também permite experimentar e testar novos recursos em um ambiente seguro e controlado. Em outro contraponto, o ambiente local do K8S possibilita acelerar o processo de desenvolvimento, uma vez que podemos testar nossas aplicações em um ambiente semelhante ao de produção.

Neste artigo, vamos ver como configurar um playground local do K8S usando o Windows Subsystem for Linux (WSL). O WSL permite executar uma distribuição do Linux em um sistema operacional Windows e, assim, executar o K8S em um ambiente Linux sem a necessidade de uma máquina virtual separada. Com o WSL, podemos criar um playground do K8S em nosso ambiente de desenvolvimento local, podendo testar e desenvolver nossas aplicações de forma mais eficiente.

Para configurar um playground do K8S no WSL vamos precisar:

  • Configurar o Hyper-V;
  • Configurar o WSL;
  • Instalar uma distribuição Ubuntu;
  • Instalar o Docker Engine;
  • Instalar Kubectl;
  • Instalar o Minikube;

Após a instalação e configuração vamos:

  • Criar uma aplicação em .NET;
  • Criar e gerenciar pods, serviços e deployments para a nossa aplicação;

Configurando o Hyper-V

Para configurar o WSL é necessário habilitar o Hyper-V com os seguintes passos:

  • Pressione a tecla Windows + R para abrir a caixa de diálogo “Executar”;
  • Digite “appwiz.cpl” e pressione Enter para abrir o Painel de Controle;
  • Clique em “Ativar ou desativar recursos do Windows” no lado esquerdo da janela;
  • Marque a caixa de seleção ao lado de “Hyper-V” e clique em “OK”;
  • O Windows instalará o Hyper-V e poderá ser necessário reiniciar o computador para concluir a instalação.

Configurando o WSL

Configurar o Windows Subsystem for Linux (WSL) no Windows é um processo simples que pode ser feito seguindo os seguintes passos:

Execute o comando no PowerShell com privilégios de administrador:

Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux

Reinicie seu Windows para que seja finalizado o processo de instalação do WSL.

Instalando o Ubuntu no WSL

Agora que temos o Hyper-V habilitado e o WSL configurado, podemos instalar o Ubuntu.

Para instalar, rode o seguinte comando no PowerShell:

wsl --install -d Ubuntu

Ao final da instalação será iniciado o processo para configurar o usuário e senha para acesso ao Ubuntu que foi instalado no WSL. Crie um usuário e senha que você irá lembrar depois.

Pronto, já temos nossa distribuição do Ubuntu configurada e pronta para instalarmos o Docker e por último configurar o K8S.

Instalando o Docker

A instalação do Docker no Windows Subsystem for Linux (WSL) será feita com os seguintes passos:

  • Abra o terminal do WSL e certifique-se de que todas as atualizações do sistema estão instaladas. Para isso, digite o seguinte comando:
sudo apt-get update && sudo apt-get upgrade
  • Vamos instalar alguns pacotes essenciais para o processo de instalação do docker:
sudo apt-get install ca-certificates curl gnupg
  • Adicione a chave GPG oficial do Docker ao seu sistema:
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
  • Adicione o repositório Docker às suas fontes do APT:
echo \
"deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
"$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
  • Atualize novamente a lista de pacotes disponíveis:
sudo apt-get update
  • Use o seguinte commando para instalar o Docker:
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
  • Adicione o usuário atual ao grupo do Docker:
sudo usermod -aG docker $USER
  • Altere o .bashrc adicionando a seguinte linha ao final:
export DOCKER_BUILDKIT=1
  • Adicione a seguinte linha ao final do arquivo /etc/wsl.confg para autoiniciar o Docker ao entrar no WSL:
[boot]
command="service docker start"
  • Desligue o WSL usando o seguinte comando no powershell:
wsl --shutdown
  • Reabra o terminal do WSL e verifique se o Docker foi instalado corretamente:
sudo docker run hello-world

Se tudo funcionou corretamente, você deve ver a mensagem “Hello from Docker!” no seu terminal como mostra a Figura 1.

Figura 1. Hello from Docker

E pronto! Agora você pode começar a usar o Docker no seu WSL.

Instalando e configurando o K8S

Existem diversas maneiras de instalar o configurar o Kubernetes (K8S) localmente para desenvolvimento e teste, mas vamos optar por uma maneira mais simples, que é usando o MiniKube.

Começaremos com o comando para baixar o binário do MiniKube:

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64

O próximo comando irá instalar o MiniKube:

sudo install minikube-linux-amd64 /usr/local/bin/minikube

Agora é iniciar o cluster com o seguinte comando:

minikube start --vm-driver=docker

Ao final da execução do comando de start, teremos o cluster executando e pronto para ser usado. Mas para conseguirmos usar, precisaremos instalar o kubectl que será nossa interface de interação com o K8S.

Para isso vamos começar usando o comando para baixar o binário do kubectl:

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

E em seguida instalar o binário com o seguinte comando:

sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl

Para validar a instalação, podemos executar o seguinte comando:

kubectl cluster-info

Este comando exibirá informações sobre o cluster Kubernetes que está sendo usado pelo MiniKube. Verifique se as informações serão exibidas corretamente, indicando que o cluster está em execução e pronto para uso bem como mostra a Figura 2.

Figura 2. Cluster info

Criando nossa aplicação em .NET

Agora que temos o ambiente do K8S configurado, podemos criar uma aplicação simples para podermos entender como executar a mesma no nosso cluster.

Vale ressaltar que esses passos de criação da aplicação podem ser feitos para outras tecnologias que você se sinta mais confortável. Desde que ao final você consiga gerar uma imagem Docker a ser usada nos passos do K8S.

Para darmos início, primeiramente certifique-se de ter instalado o sdk do .NET, caso contrário, você pode seguir os passos da documentação da Microsoft https://learn.microsoft.com/en-us/dotnet/core/install/linux?WT.mc_id=dotnet-35129-website.

O próximo passo é criar o projeto com o CLI (Command-line interface) do .NET:

dotnet new webapi -n ExemploK8S

Agora vamos criar o Dockerfile para construir uma imagem da aplicação, que iremos usar posteriormente para implantar no Kubernetes (K8s).

  • Crie um arquivo chamado `Dockerfile` (sem extensão) no diretório raiz do projeto;
  • Abra o `Dockerfile` em um editor de texto ou IDE de sua preferência, como por exemplo o Visual Studio Code;
  • Adicione o seguinte conteúdo ao `Dockerfile`:
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build-env
WORKDIR /app
COPY *.csproj ./
RUN dotnet restore
COPY . ./
RUN dotnet publish -c Release -o out
FROM mcr.microsoft.com/dotnet/aspnet:6.0
WORKDIR /app
COPY --from=build-env /app/out .
ENTRYPOINT ["dotnet", "ExemploK8S.dll"]
  • No terminal ou prompt de comando, navegue até o diretório raiz da aplicação.
  • Construa a imagem Docker executando o seguinte comando:
docker build -t exemplok8s:1.0.0 .
  • Aguarde o Docker concluir o processo de construção da imagem. Isso pode levar alguns minutos, dependendo do tamanho da aplicação e da velocidade da sua conexão com a internet.
  • Após a conclusão, você pode verificar se a imagem foi criada com sucesso executando o comando:
docker images

A imagem que você criou deve ser exibida na lista conforme a Figura 3.

Figura 3. Images Docker

Agora você tem uma imagem Docker pronta para ser usada para implantar sua aplicação .NET em um ambiente Dockerizado, incluindo o Kubernetes. Você pode usar essa imagem para executar a aplicação localmente ou implantá-la em um cluster Kubernetes usando um arquivo de manifesto de implantação. Em nosso caso vamos implantar a imagem no nosso playground local do K8S.

Implantando a aplicação no K8S

Uma forma simples de resumir o Kubernetes é dizer que ele tem como princípio a orquestração de contêineres. Sendo responsável por disponibilizar recursos, como máquinas virtuais, redes e armazenamento, conforme configurado, para as aplicações por meio de objetos declarativos, como pods, serviços e deployments. Ele automatiza a distribuição e o gerenciamento desses contêineres, garantindo que estejam em execução, escalando-os conforme necessário, balanceando a carga e lidando com possíveis falhas, proporcionando uma plataforma confiável para executar aplicações em contêineres.

Para nosso exemplo, vamos começar criando um deployment

Para isso, crie uma pasta chamada k8s na raiz do projeto e dentro dessa pasta, crie o arquivo deployment.yaml com o seguinte conteúdo

apiVersion: apps/v1
kind: Deployment
metadata:
  name: exemplok8s
spec:
  selector:
    matchLabels:
      app: exemplok8s
  template:
    metadata:
      labels:
        app: exemplok8s
    spec:
      containers:
        - name: exemplok8s
          image: exemplok8s:1.0.0
          ports:
            - containerPort: 80

Para aplicar o arquivo no nosso cluster, use o seguinte comando dentro da pasta do k8s:

kubectl apply -f deployment.yaml

E com isso temos nosso primeiro objeto criado no nosso cluster, para verificar podemos executar o comando:

kubectl get deployments
Figura 4. K8S deployments

Conforme Figura 4 podemos ver que o nosso deployment está criado, porém a coluna READY mostra que temos 0 replicas de 1 em execução, isso significa que a aplicação não subiu por algum motivo.

Uma possibilidade é a aplicação estar quebrando na hora de subir o container, e isso podemos verificar executando o comando

kubectl get pods

Que irá gerar a seguinte saída:

Figura 5. K8S PODs

Como mostra Figura 5 podemos ver que o STATUS de nosso POD é ErrImagePull, que significa basicamente que o K8S não conseguiu fazer o pull da imagem.

Um comando adicional que podemos executar para vermos mais detalhes é o:

kubectl describe pod/POD_NAME

Com esse comando podemos ver toda a especificação do POD, para nós nesse momento o mais importante é a seção Events, onde poderemos ver mais detalhadamente conforme Figura 6 a seguir o erro que está acontecendo.

Figura 6. K8S POD Events

Conforme já constatado, o problema realmente está no pull da imagem. Isso está acontecendo pelo fato de o K8S estar sendo executado no MiniKube e a imagem que criamos com o Docker só existe localmente no repositório do Docker e não no repositório do MiniKube.

Podemos verificar as imagens disponíveis no MiniKube com o seguinte comando:

minikube image ls

Que conforme Figura 7, podemos constatar realmente que a imagem da nossa aplicação não se encontra no repositório do MiniKube.

Figura 7. MiniKube images

Para resolvermos vamos fazer o build da imagem usando o MiniKube com o seguinte comando

minikube image build -t exemplok8s:1.0.0 .

Com isso podemos executar o comando para forçar a reinicialização do deployment da nossa aplicação:

kubectl rollout restart deployment/exemplok8s

E ao verificar o status do POD novamente, podemos constar que temos 1 de 1 em execução.

Nosso próximo passo é tornar o deployment acessível através do objeto service do k8s.

Para isso, crie um arquivo chamado service.yaml na pasta k8s com o seguinte conteúdo:

apiVersion: v1
kind: Service
metadata:
  name: exemplok8s-service
spec:
  selector:
    app: exemplok8s
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: NodePort

E aplique o mesmo no cluster com o seguinte comando:

kubectl apply -f service.yaml

Para acessarmos o service externamente ao cluster, podemos usar o seguinte comando do MiniKube:

minikube service exemplok8s-service

E no navegador local, acessar o Endpoint da nossa aplicação na porta exposta pelo MiniKube:

Figura 8. Expondo o service
Figura 9. Acessando a aplicação

Conclusão

Conseguimos criar um ambiente de estudo pronto para experimentarmos no Kubernetes usando o MiniKube no WSL. Realizamos várias etapas importantes, desde a configuração do ambiente até a implantação de uma aplicação .NET no cluster. No processo, aprendemos sobre a instalação e configuração do WSL, Docker e MiniKube, bem como a criação de uma aplicação .NET e sua implantação usando um Deployment e Service no Kubernetes.

Embora tenhamos abordado apenas alguns conceitos e recursos básicos do Kubernetes, é importante ressaltar que o Kubernetes é uma plataforma poderosa para gerenciar aplicativos em contêineres. Ele oferece recursos avançados, como escalabilidade, alta disponibilidade, descoberta de serviços, balanceamento de carga e muito mais. Com o Kubernetes, podemos implantar e gerenciar nossos aplicativos de forma eficiente, garantindo a disponibilidade e a escalabilidade conforme necessário.

À medida que você continua explorando o Kubernetes, recomendamos que se aprofunde em outros recursos, como namespaces, ingress, configuração avançada de implantação, serviços de descoberta, persistência de dados e monitoramento. O Kubernetes possui uma vasta documentação e uma comunidade ativa que pode ajudá-lo a aprofundar seu conhecimento e aproveitar ao máximo essa poderosa plataforma de orquestração.

Espero que este artigo tenha fornecido uma base sólida para você começar a explorar e experimentar o Kubernetes no seu ambiente de estudo local. Continue aprendendo, construindo e aproveitando os benefícios do Kubernetes em suas atividades de desenvolvimento e implantação de aplicativos.

Em caso de dúvidas, você pode usar o repositório https://github.com/pablotdv/playground-k8s para pedir ajuda ou maiores esclarecimentos!

Outras publicações

Confira todos os conteúdos