# Olá, Minikube!

LLMS index: [llms.txt](/llms.txt)

---

<!-- overview -->

Este tutorial demonstra como executar uma aplicação exemplo no Kubernetes utilizando
o minikube.
O tutorial fornece uma imagem de contêiner que utiliza o NGINX para repetir todas
as requisições.

## Objetivos

* Instalar uma aplicação exemplo no minikube.
* Executar a aplicação.
* Visualizar os logs da aplicação.

## Antes de você começar

Este tutorial assume que você já tem uma instância do `minikube` configurada.
Veja a __Etapa 1__ em [minikube start](https://minikube.sigs.k8s.io/docs/start/) para instruções de como instalar.

<div class="alert alert-info" role="note"><h4 class="alert-heading">Nota</h4>Execute apenas as instruções na <strong>Etapa 1, Instalação</strong>. O restante é coberto nesta página.</div>


Você também irá precisar instalar o `kubectl`.
Veja [instalando ferramentas](/pt-br/docs/tasks/tools/#kubectl) para instruções de como
instalar.

<!-- lessoncontent -->

## Criando um cluster do minikube

```shell
minikube start
```

## Abra o painel (_dashboard_)

Abra o painel (_dashboard_) do Kubernetes. Você pode fazer isso de duas formas
distintas:

<ul class="nav nav-tabs" id="tabs-dashboard" role="tablist"><li class="nav-item"><a data-bs-toggle="tab" class="nav-link active" href="#tabs-dashboard-0" role="tab" aria-controls="tabs-dashboard-0" aria-selected="true">Abra um navegador</a></li>
	  
		<li class="nav-item"><a data-bs-toggle="tab" class="nav-link" href="#tabs-dashboard-1" role="tab" aria-controls="tabs-dashboard-1">Copie e cole a URL</a></li></ul>

<div class="tab-content" id="tabs-dashboard-content"><div class="tab-body tab-pane fadeshow active"
        id="tabs-dashboard-0" role="tabpanel" aria-labelledby="tabs-dashboard-0-tab" tabindex="dashboard"><p>Abra um <strong>novo</strong> terminal e rode o comando:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-shell" data-lang="shell"><span class="line"><span class="cl"><span class="c1"># Inicie um novo terminal e deixe este comando rodando.</span>
</span></span><span class="line"><span class="cl">minikube dashboard
</span></span></code></pre></div><p>Agora, retorne para o terminal onde você executou o comando <code>minikube start</code>.</p>
<div class="alert alert-info" role="note"><h4 class="alert-heading">Nota</h4><p>O comando <code>dashboard</code> habilita o complemento do painel e abre o proxy no navegador
padrão. Você pode criar recursos do Kubernetes no painel, como Deployment e
Service.</p>
<p>Para descobrir como evitar invocar diretamente o navegador do terminal e obter uma URL para o painel web, consulte a aba &quot;Copiar e colar URL&quot;.</p>
<p>Por padrão, o painel só é acessível pela rede virtual interna do Kubernetes. O
comando <code>dashboard</code> cria um proxy temporário para tornar o painel acessível por
fora da rede virtual do Kubernetes.</p>
<p>Para parar o proxy, utilize o comando <code>Ctrl+C</code> para encerrar o processo.
Após o término do comando, o painel permanece executando no cluster do Kubernetes.
Você pode executar o comando <code>dashboard</code> novamente para criar outro proxy para
acessar o painel.</p>
</div>
</div><div class="tab-body tab-pane fade"
        id="tabs-dashboard-1" role="tabpanel" aria-labelledby="tabs-dashboard-1-tab" tabindex="dashboard"><p>Se você não deseja que o minikube abra um navegador para você, rode o comando
<code>dashboard</code> com a opção de linha de comando <code>--url</code>. O <code>minikube</code> irá imprimir
uma URL que você poderá abrir no navegador de sua preferência.</p>
<p>Abra um <strong>novo</strong> terminal e rode o comando:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-shell" data-lang="shell"><span class="line"><span class="cl"><span class="c1"># Inicie um novo terminal e deixe este comando rodando.</span>
</span></span><span class="line"><span class="cl">minikube dashboard --url
</span></span></code></pre></div><p>Agora, retorne para o terminal onde você executou o comando <code>minikube start</code>.</p>
</div></div>


## Criando um Deployment

Um [*Pod*](/docs/concepts/workloads/pods/) do Kubernetes consiste em um ou mais
contêineres agrupados para fins de administração e gerenciamento de rede. O Pod
deste tutorial possui apenas um contêiner. Um
[*Deployment*](/docs/concepts/workloads/controllers/deployment/) do Kubernetes
verifica a integridade do seu Pod e reinicia o contêiner do Pod caso este seja
finalizado. Deployments são a maneira recomendada de gerenciar a criação e
escalonamento dos Pods.

1. Use o comando `kubectl create` para criar um Deployment que gerencia um Pod.
   O Pod executa um contêiner baseado na imagem do Docker disponibilizada.

    ```shell
    # Execute uma imagem de contêiner de teste que inclui um servidor web
    kubectl create deployment hello-node --image=registry.k8s.io/e2e-test-images/agnhost:2.53 -- /agnhost netexec --http-port=8080
    ```

1. Visualize o Deployment:

    ```shell
    kubectl get deployments
    ```

    A saída será semelhante a:

    ```
    NAME         READY   UP-TO-DATE   AVAILABLE   AGE
    hello-node   1/1     1            1           1m
    ```

    (Pode levar algum tempo para que o pod fique disponível. Se você ver "0/1", tente novamente em alguns segundos.)

1. Visualize o Pod:

    ```shell
    kubectl get pods
    ```

    A saída será semelhante a:

    ```
    NAME                          READY     STATUS    RESTARTS   AGE
    hello-node-5f76cf6ccf-br9b5   1/1       Running   0          1m
    ```

1. Visualize os eventos do cluster:

    ```shell
    kubectl get events
    ```

1. Visualize a configuração do `kubectl`:

    ```shell
    kubectl config view
    ```

1. Visualize os logs da aplicação para um contêiner em um pod (substitua o nome do pod pelo que você obteve de `kubectl get pods`).
   
   
<div class="alert alert-info" role="note"><h4 class="alert-heading">Nota</h4>Substitua <code>hello-node-5f76cf6ccf-br9b5</code> no comando <code>kubectl logs</code> pelo nome do pod da saída do comando <code>kubectl get pods</code>.</div>

   
   ```shell
   kubectl logs hello-node-5f76cf6ccf-br9b5
   ```

   A saída será semelhante a:

   ```
   I0911 09:19:26.677397       1 log.go:195] Started HTTP server on port 8080
   I0911 09:19:26.677586       1 log.go:195] Started UDP server on port  8081
   ```


<div class="alert alert-info" role="note"><h4 class="alert-heading">Nota</h4>Para mais informações sobre o comando <code>kubectl</code>, consulte
<a href="/pt-br/docs/reference/kubectl/">visão geral do kubectl</a>.</div>


## Criando um Service

Por padrão, um Pod só é acessível utilizando o seu endereço IP interno no cluster
Kubernetes. Para disponibilizar o contêiner `hello-node` fora da rede virtual do
Kubernetes, você deve expor o Pod como um
[*Service*](/docs/concepts/services-networking/service/) do Kubernetes.

<div class="alert alert-danger" role="note"><h4 class="alert-heading">Aviso</h4>O contêiner agnhost possui um endpoint <code>/shell</code>, que é útil para
depuração, mas perigoso de expor à internet pública. Não execute isso em um
cluster voltado para a internet ou em um cluster de produção.</div>


1. Exponha o Pod usando o comando `kubectl expose`:

    ```shell
    kubectl expose deployment hello-node --type=LoadBalancer --port=8080
    ```

    O parâmetro `--type=LoadBalancer` indica que você deseja expor o seu serviço
    fora do cluster Kubernetes.
    
    A aplicação dentro da imagem de teste escuta apenas na porta TCP 8080. Se
    você usou `kubectl expose` para expor uma porta diferente, os clientes não
    conseguirão se conectar a essa outra porta.

1. Visualize o Service que você acabou de criar:

    ```shell
    kubectl get services
    ```

    A saída será semelhante a:

    ```
    NAME         TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
    hello-node   LoadBalancer   10.108.144.78   <pending>     8080:30369/TCP   21s
    kubernetes   ClusterIP      10.96.0.1       <none>        443/TCP          23m
    ```

    Em provedores de nuvem que fornecem serviços de balanceamento de carga para
    o Kubernetes, um IP externo seria provisionado para acessar o serviço. No
    minikube, o tipo `LoadBalancer` torna o serviço acessível por meio do comando
    `minikube service`.

1. Execute o comando a seguir:

    ```shell
    minikube service hello-node
    ```

    Este comando abre uma janela do navegador que serve o seu aplicativo e exibe
    o retorno da requisição ao aplicativo.

## Habilitando Complementos (addons)

A ferramenta minikube inclui um conjunto integrado de <a class='glossary-tooltip' title='Recursos que estendem a funcionalidade do Kubernetes.' data-bs-toggle='tooltip' data-bs-placement='top' href='/pt-br/docs/concepts/cluster-administration/addons/' target='_blank' aria-label='complementos'>complementos</a>
que podem ser habilitados, desabilitados e executados no ambiente Kubernetes local.

1. Liste os complementos suportados atualmente:

    ```shell
    minikube addons list
    ```

    A saída será semelhante a:

    ```
    addon-manager: enabled
    dashboard: enabled
    default-storageclass: enabled
    efk: disabled
    freshpod: disabled
    gvisor: disabled
    helm-tiller: disabled
    ingress: disabled
    ingress-dns: disabled
    logviewer: disabled
    metrics-server: disabled
    nvidia-driver-installer: disabled
    nvidia-gpu-device-plugin: disabled
    registry: disabled
    registry-creds: disabled
    storage-provisioner: enabled
    storage-provisioner-gluster: disabled
    ```

1. Habilite um complemento, por exemplo, `metrics-server`:

    ```shell
    minikube addons enable metrics-server
    ```

    A saída será semelhante a:

    ```
    The 'metrics-server' addon is enabled
    ```

1. Visualize o Pod e o Service que você acabou de criar:

    ```shell
    kubectl get pod,svc -n kube-system
    ```

    A saída será semelhante a:

    ```
    NAME                                        READY     STATUS    RESTARTS   AGE
    pod/coredns-5644d7b6d9-mh9ll                1/1       Running   0          34m
    pod/coredns-5644d7b6d9-pqd2t                1/1       Running   0          34m
    pod/metrics-server-67fb648c5                1/1       Running   0          26s
    pod/etcd-minikube                           1/1       Running   0          34m
    pod/influxdb-grafana-b29w8                  2/2       Running   0          26s
    pod/kube-addon-manager-minikube             1/1       Running   0          34m
    pod/kube-apiserver-minikube                 1/1       Running   0          34m
    pod/kube-controller-manager-minikube        1/1       Running   0          34m
    pod/kube-proxy-rnlps                        1/1       Running   0          34m
    pod/kube-scheduler-minikube                 1/1       Running   0          34m
    pod/storage-provisioner                     1/1       Running   0          34m

    NAME                           TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)             AGE
    service/metrics-server         ClusterIP   10.96.241.45    <none>        80/TCP              26s
    service/kube-dns               ClusterIP   10.96.0.10      <none>        53/UDP,53/TCP       34m
    service/monitoring-grafana     NodePort    10.99.24.54     <none>        80:30002/TCP        26s
    service/monitoring-influxdb    ClusterIP   10.111.169.94   <none>        8083/TCP,8086/TCP   26s
    ```

1. Verifique a saída do `metrics-server`:

    ```shell
    kubectl top pods
    ```

    A saída será semelhante a:

    ```
    NAME                         CPU(cores)   MEMORY(bytes)   
    hello-node-ccf4b9788-4jn97   1m           6Mi             
    ```

    Se você ver a mensagem a seguir, aguarde e tente novamente:

    ```
    error: Metrics API not available
    ```

1. Desabilite o complemento `metrics-server`:

    ```shell
    minikube addons disable metrics-server
    ```

    A saída será semelhante a:

    ```
    metrics-server was successfully disabled
    ```

## Limpeza

Agora você pode remover todos os recursos criados no seu cluster:

```shell
kubectl delete service hello-node
kubectl delete deployment hello-node
```

Encerre o cluster do minikube:

```shell
minikube stop
```

Opcionalmente, apague a máquina virtual (VM) do minikube:

```shell
# Opcional
minikube delete
```

Se você desejar utilizar o minikube novamente para aprender mais sobre o Kubernetes,
você não precisa apagar a VM.

## Conclusão

Esta página cobriu os aspectos básicos para colocar um cluster minikube em funcionamento. Agora você está pronto para implantar aplicações.

## Próximos passos


* Tutorial para _[implantar seu primeiro aplicativo no Kubernetes com kubectl](/docs/tutorials/kubernetes-basics/deploy-app/deploy-intro/)_.
* Aprenda mais sobre [objetos Deployment](/docs/concepts/workloads/controllers/deployment/).
* Aprenda mais sobre [implantar aplicações](/docs/tasks/run-application/run-stateless-application-deployment/).
* Aprenda mais sobre [objetos Service](/docs/concepts/services-networking/service/).
