Iniciando com Kubernetes: Rodando seu Próprio Cluster local 🚀
Tags: kubernetes, sre, devops, opensource
Published: 2023-08-02 19:22:27

Fala pessoal! Para o meu primeiro post, escolhi escrever sobre um assunto que gosto muito e que está sempre em alta! Vamos falar de Kubernetes, e se você caiu aqui e não está familiarizado com essa ferramenta, continue lendo que vou tentar te ajudar!

Vou dar uma breve explicação do que é o Kubernetes, sem entrar em detalhes, e no futuro está nos meus planos fazer um post mais detalhado sobre Kubernetes e toda a arquitetura envolvida.

## O que é o Kubernetes ?
O Kubernetes, também conhecido como "k8s", é uma plataforma de orquestração de containers que automatiza parte dos processos envolvidos na administração de aplicações, implantação, monitoramento e escalonamento. 

Foi desenvolvido internamente pelo Google e hoje é um software de código aberto, mantido pela comunidade e por grandes empresas, como a própria Google e a Red Hat.

## Instalando o KinD

Para prosseguirmos no nosso lab local, vamos fazer a instalação de uma ferramenta chamada KinD (Kubernetes in Docker), e para isso vai ser necessário ter o Docker e o Golang instalado na sua máquina. Você pode seguir a documentação oficial de como instalar essas ferramentas.

- [Instalando Golang](https://go.dev/dl/)
- [Instalando Docker](https://docs.docker.com/get-docker/)

### O que é o KinD
KinD é uma ferramenta de linha de comando desenvolvida em Golang e tem como proposito criar clusters Kubernetes utilizando containers Docker como "nodes". 

Ela foi desenvolvida com o intuito de facilitar o nosso trabalho de gerenciamento de cluster em ambientes locais. Isso pode te ajudar tanto no momento de conhecer o Kubernetes, como pode te servir sendo um ambiente de teste local para aplicações que tu esteja desenvolvendo.

**Instalando o KinD:**

```
go install sigs.k8s.io/kind@v0.20.0
```

### Criando o primeiro cluster
Para darmos inicio, escolhi criar um cluster onde faremos o deploy de um Nginx com acesso na porta 80 do nosso ambiente local.

Para isso, precisamos criar um arquivo de configuração para dizer ao KinD que vamos utilizar alguma porta do nosso Host(sua máquina local), pois por padrão o KinD não faz o mapeamento na criação do cluster. Chamei o arquivo de `config.yaml` e abaixo tem o conteúdo dele:

```
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
  extraPortMappings:
  - containerPort: 30250
    hostPort: 80
```

Com o arquivo criado, precisamos rodar o KinD passando o arquivo como parametro de configuração e para isso vamos usar a opção de `--config`:

```
kind create cluster --name lab --config config.yaml
```

Nesse processo, o KinD vai criar um container para servir como o seu cluster Kubernetes, e também configurar seu acesso ao cluster fazendo as alterações no arquivo **~/.kube/config**, isso pode demorar alguns minutos, então fique a vontade para pegar um café :)

Após seu cluster ter sido criado, você vai conseguir usar a linha de comando do `kubectl` para fazer a criação de recursos dentro do seu cluster. 

- [Instalando o Kubectl](https://kubernetes.io/docs/tasks/tools/)

Após a instalação do kubectl, execute esse comando:

```
kubectl cluster-info --context kind-lab
```
O resultado deve ser esse:

```
kubectl cluster-info --context kind-lab
Kubernetes control plane is running at https://127.0.0.1:59473
CoreDNS is running at https://127.0.0.1:59473/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.
```

## Criando nosso Nginx
Agora que temos o nosso cluster Kubernetes de pé, vamos criar um deployment para o nosso Nginx, junto desse deployment vamos criar um service para que possamos acessar o nosso Nginx.
Salve esse arquivo como `nginx.yaml`.

```
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    name: nginx-deployment
    environment: lab
spec:
  selector:
    matchLabels:
      name: nginx
  replicas: 2
  template:
    metadata:
      labels:
        name: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        resources:
          limits:
            memory: "128Mi"
            cpu: "500m"
        ports:
          - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name:  nginx
spec:
  type:  NodePort
  ports:
  - name:  http
    nodePort: 30250
    port:  80
  selector:
    name: nginx
```
### Aplicando o yaml do Nginx
Com o arquivo salvo, vamos utilizar o comando apply do kubectl para fazer o provisionamento do deployment e do service necessários para que possamos acessar esse Nginx.
```
kubectl apply -f nginx.yaml
```

O resultado deve ser esse:

```
deployment.apps/nginx-deployment created
service/nginx created
```

Agora com os recursos criados, você pode acessar o endereço http://localhost no seu navegador e deve ter um resultado como esse:


![Acesso Nginx local](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4geiuwqeorubeh224rx3.png)

Espero que possa ter te ajudado e não ter sido prolixo!
Ah, e os códigos envolvidos nesse post estão nesse [repositorio](https://github.com/MatheusGuizolfi/k8s-kind-nodeport).

Qualquer dúvida, comentário, critica ou sugestão, fique a vontade e deixe um comentário.

E estou aceitando sugestões de assuntos para criar novos posts!
Forte abraço!