# Tutorial Kubernetes: aprenda como instalar

O Kubernetes (também chamado de K8s) permite gerenciar de forma eficiente grandes quantidades de contêineres e automatiza muitos processos no desenvolvimento de software. Com apenas alguns passos, é possível instalar um cluster Kubernetes robusto e começar a utilizá-lo de maneira produtiva.

## Passo 1: Preparar o sistema

Neste tutorial Kubernetes, mostramos como realizar a instalação no Ubuntu.

No primeiro passo, é necessário preparar o sistema, atualizando-o e instalando todas as dependências necessárias. Para isso, abra o terminal e execute a atualização do sistema, garantindo que todos os pacotes estejam atualizados:

```bash
sudo apt update && sudo apt upgrade -y
```

Em seguida, instale as principais ferramentas auxiliares necessárias para a instalação do Kubernetes e do Minikube. Use o seguinte comando:

```bash
sudo apt install -y curl wget apt-transport-https ca-certificates gnupg lsb-release
```

Esses utilitários garantem que você possa utilizar fontes externas com segurança e baixar ou instalar outros pacotes de software sem problemas.

## Passo 2: Instalar o kubectl

O [Kubernetes](https://www.ionos.com/pt-br/digitalguide/servidor/conhecimento/o-que-e-kubernetes/) funciona com diferentes servidores: o **Master** e os **Nodes**. Eles não precisam estar necessariamente em máquinas físicas separadas. Com o uso de máquinas virtuais, é possível ativar múltiplos nós Kubernetes em um único computador. Principalmente para testes, o programa gratuito Minikube tem se mostrado muito útil. Ele permite trabalhar com Kubernetes de forma local. Como o Minikube precisa de uma máquina virtual ou do Docker, o programa depende de um [hipervisor](https://www.ionos.com/pt-br/digitalguide/servidor/conhecimento/o-que-e-hypervisor/) ou de um software de contêineres. Além disso, é indispensável a utilização da ferramenta **kubectl**, que será o principal utilitário de linha de comando para gerenciar o cluster no decorrer deste tutorial Kubernetes.

Nota Neste tutorial Kubernetes, mostramos o processo de início utilizando o Docker. No entanto, você também pode realizar os mesmos passos com um software de virtualização, como o VirtualBox.

Primeiro, instale o **kubectl (Kube Control)** no seu sistema. Esse programa é essencial **para gerenciar o cluster**.

```bash
curl -LO "https://dl.k8s.io/release/$(curl -Ls https://dl.k8s.io/release/stable.txt)/bin/linux/arm64/kubectl"
chmod +x kubectl
sudo mv kubectl /usr/local/bin/
```

Nota Os comandos de instalação podem variar dependendo da arquitetura do seu sistema.

## Passo 3: Instalar o Docker

Antes de usar o Minikube, é necessário garantir que o Docker esteja instalado no seu sistema. O Docker funciona como *container runtime* e permite que o Minikube execute um cluster Kubernetes sem precisar de um software de virtualização. Instale o Docker com o seguinte comando:

```bash
sudo apt install -y docker.io
```

Para poder utilizar o Docker sem permissões de superusuário (root), adicione seu usuário ao grupo do Docker:

```bash
sudo usermod -aG docker $USER
newgrp docker
```

Talvez seja necessário encerrar a sessão e fazer login novamente para que a associação ao grupo seja ativada. Por fim, teste a instalação com:

```bash
docker run hello-world
```

Se aparecer uma breve mensagem de sucesso, o Docker foi instalado corretamente e já está pronto para ser usado com o Minikube no decorrer deste tutorial kubernetes.

## Passo 4: Instalar e iniciar o Minikube

No próximo passo, você instalará o Minikube em uma versão compatível, utilizando o Docker como driver. Primeiro, baixe a versão mais recente do Minikube, torne o arquivo executável e mova-o para um diretório do sistema, de forma que o comando fique disponível globalmente:

```bash
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-arm64
chmod +x minikube-linux-arm64
sudo mv minikube-linux-arm64 /usr/local/bin/minikube
```

Após a instalação, verifique se o Minikube foi configurado corretamente com:

```bash
minikube version
```

Em seguida, inicie o Minikube com o seguinte comando:

```bash
minikube start --driver=docker
```

Nesse cenário, o Minikube utiliza o Docker como *container runtime* e cria o cluster Kubernetes diretamente dentro do ambiente do Docker. Durante a inicialização do Minikube, o kubectl deve ser configurado automaticamente. Caso queira alternar da linha de comando para uma GUI, utilize o comando abaixo. Ele abrirá o **Dashboard** no seu navegador padrão:

```bash
minikube dashboard
```

[![Imagem: Captura de tela do Dashboard do Kubernetes](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/6/7/csm_kubernetes-dashboard_549c1e7bb8.webp "Captura de tela do Dashboard do Kubernetes")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/kubernetes-dashboard.jpg) Dashboard do Kubernetes ## Passo 5: Utilizar o Kubernetes

Ao iniciar o Minikube, o programa cria automaticamente um **cluster** com um único nó (Node). Você pode verificar isso com um comando simples do kubectl:

```bash
kubectl get nodes
```

Pelo **Dashboard**, você pode agora **criar deployments**. Clique no botão *Create* (ícone de “+” no canto superior direito) e será aberto um editor baseado na web. Nesse editor, você pode definir um deployment nos formatos [JSON](https://www.ionos.com/pt-br/digitalguide/servidor/conhecimento/o-que-e-json/) ou YAML. Após criar o deployment, o Kubernetes gera automaticamente múltiplos **pods**. Se desejar ajustar a quantidade, basta **escalar o deployment**. Essa opção pode ser acessada clicando no botão com três pontos ao lado do deployment.

[![Imagem: Dashboard do Kubernetes com deployment e três pods](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/f/9/csm_kubernetes-overview-deployment-pods_70f88067c3.webp "Dashboard do Kubernetes com deployment e três pods")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/kubernetes-overview-deployment-pods.jpg)[![Imagem: Escalonamento de um deployment no Kubernetes](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/3/b/csm_kubernetes-scale-resources_a09c6390b2.webp "Escalonamento de um deployment no Kubernetes")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/kubernetes-scale-resources.jpg) Kubernetes: escalonamento de um deployment Como alternativa, você também pode criar deployments diretamente pelo terminal. Para isso, o conteúdo já deve estar integrado em uma imagem Docker, armazenada em um repositório.

```bash
kubectl create deployment --image=[caminho-da-imagem]
```

Por meio da linha de comando, é possível obter diversas informações úteis sobre o cluster: **Quais deployments existem?**

```bash
kubectl get deployments
```

**Quantos pods estão ativos?**

```bash
kubectl get pods
```

**Quais services existem?**

```bash
kubectl get services
```

**Quais nodes estão ativos?**

```bash
kubectl get nodes
```

[![Imagem: Terminal com diferentes comandos do Kubernetes e seus respectivos outputs](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/f/5/csm_screenshot-kubernetes-ubuntu-terminal_4c2f4d2127.webp "Terminal com diferentes comandos do Kubernetes e seus respectivos outputs")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/screenshot-kubernetes-ubuntu-terminal.jpg) Comandos do Kubernetes no terminal ## Passo 6: Publicar um deployment

Até aqui, você iniciou seu deployment, mas ainda não o publicou. Para disponibilizá-lo, é necessário criar um **service**:

```bash
kubectl expose deploy test-deployment
```

Dessa forma, o service estará disponível apenas **dentro do cluster**. Para permitir acesso também **fora do cluster**, adicione algumas flags extras:

```bash
kubectl expose deploy test-deployment --type=LoadBalancer --port=8080
```

Com o Minikube, é possível **iniciar o service** diretamente com:

```bash
minikube service test-deployment
```

Se quiser **excluir o service**, use o comando:

```bash
kubectl delete service test-deployment
```

Da mesma forma, o **deployment também pode ser removido**:

```bash
kubectl delete deployment test-deployment
```

Para **encerrar o Minikube**, basta parar o processo:

```bash
minikube stop
```

E, se você não pretende mais utilizar a VM ou o *container runtime*, pode excluir completamente o ambiente:

```bash
minikube delete
```

Após a exclusão, todas as configurações, deployments e pods criados serão removidos. Ao iniciar o Minikube novamente, você terá um **cluster limpo e vazio**, pronto para novos testes e experimentos.


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/servidor/configuracao/tutorial-kubernetes/](https://www.ionos.com/pt-br/digitalguide/servidor/configuracao/tutorial-kubernetes/) for AI/LLM consumption.