Essa seção da documentação contém tutoriais. Um tutorial demonstra como realizar
um objetivo mais complexo que uma simples tarefa. Tipicamente,
um tutorial é dividido em várias seções, em que cada seção tem uma sequência de
passos.
Antes de iniciar um tutorial, é interessante que você salve a página do
Glossário Padronizado para futuras referências.
Noções Básicas
Noções Básicas do Kubernetes é um
tutorial interativo que auxilia no entendimento do ecossistema Kubernetes, bem
como permite testar algumas funcionalidades básicas do Kubernetes.
Se você desejar escrever um tutorial, consulte a documentação de
Tipos de Página de Conteúdo
para informações sobre o tipo de página de tutorial.
1 - Olá, Minikube!
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 minikube start para instruções
de como instalar.
Você também irá precisar instalar o kubectl.
Veja instalando ferramentas para instruções de como
instalar.
Criando um cluster do minikube
minikube start
Abra o painel (dashboard)
Abra o painel (dashboard) do Kubernetes. Você pode fazer isso de duas formas
distintas:
# Inicie um novo terminal e deixe este comando rodando.minikube dashboard
Agora, retorne para o terminal onde você executou o comando minikube start.
Nota:
O comando dashboard 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.
Se você estiver executando num ambiente com o usuário root, veja
Abrir o Painel com URL.
Por padrão, o painel só é acessível pela rede virtual interna do Kubernetes. O
comando dashboard cria um proxy temporário para tornar o painel acessível por
fora da rede virtual do Kubernetes.
Para parar o proxy, utilize o comando Ctrl+C para encerrar o processo.
Após o término do comando, o painel permanece executando no cluster do Kubernetes.
Você pode executar o comando dashboard novamente para criar outro proxy para
acessar o painel.
Se você não deseja que o minikube abra um navegador para você, rode o comando
dashboard com a opção de linha de comando --url. O minikube irá imprimir
uma URL que você poderá abrir no navegador de sua preferência.
Abra um novo terminal e rode o comando:
# Inicie um novo terminal e deixe este comando rodando.minikube dashboard --url
Agora, retorne para o terminal onde você executou o comando minikube start.
Criando um Deployment
Um Pod 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 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.
Usando o comando kubectl create para criar um Deployment que gerencia um Pod.
O Pod executa um contêiner baseado na imagem do Docker disponibilizada.
Por padrão, um Pod só é acessível utilizando o seu endereço IP interno no cluster
Kubernetes. Para dispobiblilizar o contêiner hello-node fora da rede virtual do
Kubernetes, você deve expor o Pod como um
Service do Kubernetes.
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.
Visualize o serviço que você acabou de criar:
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.
Execute o comando a seguir:
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 complementos
que podem ser habilitados, desabilitados e executados no ambiente Kubernetes local.
The interactive tutorials on this website are being shut down. The Kubernetes
project hopes to reinstate a similar interactive learning option in the long
term.
The shutdown follows O'Reilly Media's 2019 acquisition
of Katacoda.
Kubernetes is grateful to O'Reilly and Katacoda for many years of helping
people take their first steps in learning Kubernetes.
Este tutorial fornece instruções básicas sobre o sistema de orquestração
de cluster do Kubernetes. Cada módulo contém algumas informações básicas
sobre os principais recursos e conceitos do Kubernetes e inclui um tutorial
online interativo. Esses tutoriais interativos permitem que você mesmo
gerencie um cluster simples e seus aplicativos em contêineres.
Usando os tutoriais interativos, você pode aprender a:
Implantar um aplicativo em contêiner em um cluster.
Dimensionar a implantação.
Atualizar o aplicativo em contêiner com uma nova versão do software.
Depurar o aplicativo em contêiner.
Os tutoriais usam Katacoda para executar um terminal virtual em seu navegador da Web, executado em Minikube, uma implantação local em pequena escala do Kubernetes que pode ser executada em qualquer lugar. Não há necessidade de instalar nenhum software ou configurar nada; cada tutorial interativo é executado diretamente no navegador da web.
O que o Kubernetes pode fazer por você?
Com os serviços da Web modernos, os usuários esperam que os aplicativos estejam disponíveis 24 horas por dia, 7 dias por semana, e os desenvolvedores esperam implantar novas versões desses aplicativos várias vezes ao dia. A conteinerização ajuda a empacotar o software para atender a esses objetivos, permitindo que os aplicativos sejam lançados e atualizados de maneira fácil e rápida, sem tempo de inatividade. O Kubernetes ajuda a garantir que esses aplicativos em contêiner sejam executados onde e quando você quiser e os ajuda a encontrar os recursos e ferramentas de que precisam para funcionar. Kubernetes é uma plataforma de código aberto pronta para produção, projetada com a experiência acumulada do Google em orquestração de contêineres, combinada com as melhores idéias da comunidade.
Inicie um cluster Kubernetes usando um terminal online.
Clusters do Kubernetes
O Kubernetes coordena um cluster com alta disponibilidade de computadores conectados para funcionar como uma única unidade.
As abstrações no Kubernetes permitem implantar aplicativos em contêineres em um cluster sem amarrá-los especificamente as máquinas individuais.
Para fazer uso desse novo modelo de implantação, os aplicativos precisam ser empacotados de uma forma que os desacoplem dos hosts individuais: eles precisam ser empacotados em contêineres. Os aplicativos em contêineres são mais flexíveis e disponíveis do que nos modelos de implantação anteriores, nos quais os aplicativos eram instalados diretamente em máquinas específicas como pacotes profundamente integrados ao host.
O Kubernetes automatiza a distribuição e o agendamento de contêineres de aplicativos em um cluster de maneira mais eficiente.
O Kubernetes é uma plataforma de código aberto e está pronto para produção.
Um cluster Kubernetes consiste em dois tipos de recursos:
A Camada de gerenciamento (Control Plane) coordena o cluster
Os Nós (Nodes) são os nós de processamento que executam aplicativos
Resumo:
Cluster do Kubernetes
Minikube
O Kubernetes é uma plataforma de código aberto de nível de produção que orquestra o agendamento e a execução de contêineres de aplicativos dentro e entre clusters de computador.
Diagrama de Cluster
A camada de gerenciamento é responsável por gerenciar o cluster. A camada de gerenciamento coordena todas as atividades em seu cluster, como programação de aplicativos, manutenção do estado desejado dos aplicativos, escalonamento de aplicativos e lançamento de novas atualizações.
Um nó é uma VM ou um computador físico que atua como um nó de processamento em um cluster Kubernetes. Cada nó tem um Kubelet, que é um agente para gerenciar o nó e se comunicar com a camada de gerenciamento do Kubernetes. O nó também deve ter ferramentas para lidar com operações de contêiner, como containerd ou Docker. Um cluster Kubernetes que lida com o tráfego de produção deve ter no mínimo três nós.
As camadas de gerenciamento gerenciam o cluster e os nós que são usados para hospedar os aplicativos em execução.
Ao implantar aplicativos no Kubernetes, você diz à camada de gerenciamento para iniciar os contêineres de aplicativos. A camada de gerenciamento agenda os contêineres para serem executados nos nós do cluster. Os nós se comunicam com o camada de gerenciamento usando a API do Kubernetes , que a camada de gerenciamento expõe. Os usuários finais também podem usar a API do Kubernetes diretamente para interagir com o cluster.
Um cluster Kubernetes pode ser implantado em máquinas físicas ou virtuais. Para começar o desenvolvimento do Kubernetes, você pode usar o Minikube. O Minikube é uma implementação leve do Kubernetes que cria uma VM em sua máquina local e implanta um cluster simples contendo apenas um nó. O Minikube está disponível para sistemas Linux, macOS e Windows. A linha de comando (cli) do Minikube fornece operações básicas de inicialização para trabalhar com seu cluster, incluindo iniciar, parar, status e excluir. Para este tutorial, no entanto, você usará um terminal online fornecido com o Minikube pré-instalado.
Agora que você sabe o que é Kubernetes, vamos para o tutorial online e iniciar nosso primeiro cluster!
Implante seu primeiro aplicativo no Kubernetes com o kubectl.
Implantações do Kubernetes
Assim que o seu cluster Kubernetes estiver em execução você pode implementar seu aplicativo em contêiners nele.
Para fazer isso, você precisa criar uma configuração do tipo Deployment do Kubernetes. O Deployment define como criar e
atualizar instâncias do seu aplicativo. Depois de criar um Deployment, o Master do Kubernetes
agenda as instâncias do aplicativo incluídas nesse Deployment para ser executado em nós individuais do Cluster.
Depois que as instâncias do aplicativo são criadas, um Controlador do Kubernetes Deployment monitora continuamente essas instâncias.
Se o nó que hospeda uma instância ficar inativo ou for excluído, o controlador de Deployment substituirá a instância por uma instância em outro nó no cluster.
Isso fornece um mecanismo de autocorreção para lidar com falhas ou manutenção da máquina.
Em um mundo de pré-orquestração, os scripts de instalação costumavam ser usados para iniciar aplicativos, mas não permitiam a recuperação de falha da máquina.
Ao criar suas instâncias de aplicativo e mantê-las em execução entre nós, as implantações do Kubernetes fornecem uma abordagem fundamentalmente diferente para o gerenciamento de aplicativos.
Resumo:
Deployments
Kubectl
O tipo Deployment é responsável por criar e atualizar instâncias de seu aplicativo
Implantar seu primeiro aplicativo no Kubernetes
Você pode criar e gerenciar uma implantação usando a interface de linha de comando do Kubernetes, Kubectl .
O Kubectl usa a API Kubernetes para interagir com o cluster. Neste módulo, você aprenderá os comandos Kubectl mais comuns necessários para criar implantações que executam seus aplicativos em um cluster Kubernetes.
Quando você cria um Deployment, você precisa especificar a imagem do contêiner para seu aplicativo e o número de réplicas que deseja executar.
Você pode alterar essas informações posteriormente, atualizando sua implantação; Módulos5 e 6 do bootcamp explica como você pode dimensionar e atualizar suas implantações.
Os aplicativos precisam ser empacotados em um dos formatos de contêiner suportados para serem implantados no Kubernetes
Para sua primeira implantação, você usará um aplicativo Node.js empacotado em um contêiner Docker.(Se você ainda não tentou criar um aplicativo Node.js e implantá-lo usando um contêiner, você pode fazer isso primeiro seguindo as instruções do tutorial Olá, Minikube!).
Agora que você sabe o que são implantações (Deployment), vamos para o tutorial online e implantar nosso primeiro aplicativo!
2.2.2 - Tutorial interativo - implantando um aplicativo
Um pod é a unidade de execução básica de um aplicativo Kubernetes. Cada pod representa uma parte de uma carga de trabalho em execução no cluster. Saiba mais sobre pods.
Para interagir com o Terminal, use a versão desktop/tablet
Aprenda como depurar aplicações do Kubernetes utilizando
kubectl get, kubectl describe, kubectl logs e
kubectl exec.
Objetivos
Aprenda sobre Pods do Kubernetes.
Aprenda sobre Nós do Kubernetes.
Solucione problemas de aplicativos implantados no Kubernetes.
Kubernetes Pods
Quando você criou um Deployment no Módulo
2,
o Kubernetes criou um Pod para hospedar a instância do
seu aplicativo. Um Pod é uma abstração do Kubernetes que representa
um grupo de um ou mais contêineres de aplicativos (como Docker)
e alguns recursos compartilhados para esses contêineres. Esses
recursos incluem:
Armazenamento compartilhado, como Volumes
Rede, como um endereço IP único no cluster
Informações sobre como executar cada contêiner, como a
versão da imagem do contêiner ou portas específicas a serem
usadas
Um Pod define um "host lógico" específico para o aplicativo e
pode conter diferentes contêineres de aplicativos que, na maioria
dos casos, são fortemente acoplados. Por exemplo, um Pod pode
incluir tanto o contêiner com seu aplicativo Node.js quanto um
outro contêiner que alimenta os dados a serem publicados pelo
servidor web do Node.js. Os contêineres de um Pod compartilham
um endereço IP e intervalo de portas, são sempre co-localizados,
co-alocados e executam em um contexto compartilhado no mesmo Nó.
Pods são a unidade atômica na plataforma Kubernetes. Quando
criamos um Deployment no Kubernetes, esse Deployment cria Pods
com contêineres dentro dele (em vez de você criar contêineres
diretamente). Cada Pod está vinculado ao nó onde está alocado
e lá permanece até o encerramento (de acordo com a política de
reinicialização) ou exclusão. Em caso de falha do nó, Pods
idênticos são alocados em outros nós disponíveis no cluster.
Sumário:
Pods
Nós
Principais comandos do Kubectl
Um Pod é um grupo de um ou mais contêineres de
aplicativos (como Docker) que inclui armazenamento
compartilhado (volumes), endereço IP e informações
sobre como executá-los.
Visão geral sobre os Pods
Nós
Um Pod sempre será executado em um Nó. Um Nó é uma
máquina de processamento em um cluster Kubernetes e pode ser
uma máquina física ou virtual. Cada Nó é gerenciado pela
Camada de Gerenciamento. Um Nó pode possuir múltiplos Pods e a
Camada de Gerenciamento do Kubernetes gerencia automaticamente
a alocação dos Pods nos nós do cluster. A alocação automática
dos Pods pela Camada de Gerenciamento leva em consideração os
recursos disponíveis em cada Nó.
Cada Nó do Kubernetes executa pelo menos:
O Kubelet, que é o processo responsável pela comunicação entre a
Camada de Gerenciamento e o Nó; gerencia os Pods e os contêineres
rodando em uma máquina.
Um agente de execução de contêiner (por exemplo, Docker)
responsável por baixar a imagem do contêiner de um registro
de imagens (por exemplo, o Docker Hub),
extrair o contêiner e executar a aplicação.
Os contêineres só devem ser alocados juntos em um único Pod se
estiverem fortemente acoplados e precisarem compartilhar recursos,
como disco, por exemplo.
Visão Geral sobre os Nós
Solucionando problemas usando o comando kubectl
No Módulo 2,
você usou a ferramenta de linha de comando kubectl. Você irá continuar
utilizando o kubectl no Módulo 3 para obter informação sobre aplicações
implantadas e seus recursos. As operações mais comuns podem ser
efetuadas com os comandos abaixo:
kubectl get - listar recursos
kubectl describe - mostrar informações detalhadas sobre um recurso
kubectl logs - mostrar os logs de um contêiner em um Pod
kubectl exec - executar um comando em um contêiner em um Pod
Você pode usar esses comandos para verificar quando o Deployment foi
criado, qual seu status atual, onde os Pods estão rodando e quais são
as suas configurações.
Agora que sabemos mais sobre os componentes de um cluster Kubernetes
e o comando kubectl, vamos explorar a nossa aplicação.
Um nó é uma máquina de processamento do Kubernetes e pode ser
uma VM ou máquina física, dependendo do cluster. Vários Pods
podem ser executados em um nó.
Verifique a configuração da aplicação
Vamos verificar que a aplicação que implantamos no cenário anterior
está executando. Iremos utilizar o comando kubectl get
e procurar por Pods existentes:
kubectl get pods
Se nenhum Pod estiver rodando, aguarde alguns instantes e liste os
Pods novamente. Você pode continuar assim que ver um Pod rodando.
A seguir, para visualizar quais contêineres encontram-se no Pod e quais
imagens foram utilizadas para criar tais contêineres iremos usar o
comando kubectl describe pods:
kubectl describe pods
Vemos aqui detalhes a respeito dos contêineres do Pod: endereço IP,
portas utilizadas e uma lista de eventos relacionados ao ciclo de vida
do Pod.
A saída do subcomando describe é extensa e cobre alguns
conceitos que não foram explicados ainda. Não se preocupe, estes
conceitos serão familiares até o fim deste bootcamp.
Nota: o subcomando describe pode ser utilizado
para obter informações detalhadas sobre a maioria das primitivas do
Kubernetes, incluindo Nós (Nodes), Pods e Deployments. A saída do
subcomando describe é projetada para ser legível por humanos,
não para ser consumida por processos automatizados.
Exiba a aplicação no terminal
Lembre-se que Pods estão executando em uma rede isolada e privada -
portanto, precisaremos de um proxy para acessá-los, a fim de tornar
possível a depuração e a interação com estes objetos. Para inicializar
um proxy, utilizaremos o comando kubectl proxy em um
segundo terminal. Abra uma nova janela do terminal,
e nesta nova janela, execute o comando:
kubectl proxy
Agora iremos novamente obter o nome do Pod e obter informações do Pod
diretamente através do proxy. Para obter o nome do Pod e armazená-lo
na variável de ambiente POD_NAME, utilize o comando:
export POD_NAME="$(kubectl get pods -o go-template --template
'{{range .items}}{{.metadata.name}}{{"\n"}}{{end}}')" echo Nome do Pod: $POD_NAME
Para ver a saída da aplicação, execute uma requisição com o comando
curl:
Qualquer mensagem que normalmente seria impressa na saída padrão (stdout)
torna-se parte do log do contêiner dentro do Pod. Podemos obter tais
logs utilizando o comando kubectl logs:
kubectl logs "$POD_NAME"
Nota: não é necessário especificarmos o nome do
contêiner pois temos apenas um contêiner neste Pod.
Executando comandos no contêiner
Podemos executar comandos diretamente no contêiner uma vez que o
Pod esteja criado e rodando. Para isso, utilizaremos o subcomando
exec e o nome do Pod como um parâmetro. Vamos listar
as variáveis de ambiente:
kubectl exec "$POD_NAME" -- env
Novamente, vale a pena mencionar que o nome do contêiner pode ser
omitido pois temos apenas um contêiner no Pod.
A seguir, vamos iniciar uma sessão do bash no contêiner do Pod:
kubectl exec -ti $POD_NAME -- bash
Agora temos um terminal aberto no contêiner onde nossa aplicação
Node.js está executando. O código-fonte da aplicação encontra-se
no arquivo server.js:
cat server.js
Você pode verificar que a aplicação está rodando utilizando uma
requisição com o comando curl:
curl http://localhost:8080
Nota: aqui utilizamos localhost pois
executamos o comando dentro do Pod do Node.js. Se você não conseguir
conectar-se a localhost:8080, certifique-se de que você utilizou
o comando kubectl exec e que está rodando a requisição
curl de dentro do Pod.
Para encerrar sua conexão ao contêiner, digite exit.
2.4.1 - Utilizando um serviço para expor seu aplicativo
Objetivos
Aprenda sobre um Serviço no Kubernetes
Entenda como os objetos labels e LabelSelector se relacionam a um Serviço
Exponha uma aplicação externamente ao cluster Kubernetes usando um Serviço
Visão Geral de Serviços Kubernetes
Pods Kubernetes são efêmeros. Na verdade, Pods possuem um ciclo de vida. Quando um nó de processamento morre, os Pods executados no nó também são perdidos. A partir disso, o ReplicaSet pode dinamicamente retornar o cluster ao estado desejado através da criação de novos Pods para manter sua aplicação em execução. Como outro exemplo, considere um backend de processamento de imagens com 3 réplicas. Estas réplicas são intercambiáveis; o sistema front-end não deveria se importar com as réplicas backend ou ainda se um Pod é perdido ou recriado. Dito isso, cada Pod em um cluster Kubernetes tem um único endereço IP, mesmo Pods no mesmo nó, então há necessidade de ter uma forma de reconciliar automaticamente mudanças entre Pods de modo que sua aplicação continue funcionando.
Um serviço no Kubernetes é uma abstração que define um conjunto lógico de Pods e uma política pela qual acessá-los. Serviços permitem um baixo acoplamento entre os Pods dependentes. Um serviço é definido usando YAML (preferencialmente) ou JSON, como todos objetos Kubernetes. O conjunto de Pods selecionados por um Serviço é geralmente determinado por um seletor de rótulos LabelSelector (veja abaixo o motivo pelo qual você pode querer um Serviço sem incluir um seletor selector na especificação spec).
Embora cada Pod tenha um endereço IP único, estes IPs não são expostos externamente ao cluster sem um Serviço. Serviços permitem que suas aplicações recebam tráfego. Serviços podem ser expostos de formas diferentes especificando um tipo type na especificação do serviço ServiceSpec:
ClusterIP (padrão) - Expõe o serviço sob um endereço IP interno no cluster. Este tipo faz do serviço somente alcançável de dentro do cluster.
NodePort - Expõe o serviço sob a mesma porta em cada nó selecionado no cluster usando NAT. Faz o serviço acessível externamente ao cluster usando <NodeIP>:<NodePort>. Superconjunto de ClusterIP.
LoadBalancer - Cria um balanceador de carga externo no provedor de nuvem atual (se suportado) e assinala um endereço IP fixo e externo para o serviço. Superconjunto de NodePort.
ExternalName - Expõe o serviço usando um nome arbitrário (especificado através de externalName na especificação spec) retornando um registro de CNAME com o nome. Nenhum proxy é utilizado. Este tipo requer v1.7 ou mais recente de kube-dns.
Adicionalmente, note que existem alguns casos de uso com serviços que envolvem a não definição de selector em spec. Serviços criados sem selector também não criarão objetos Endpoints correspondentes. Isto permite usuários mapear manualmente um serviço a endpoints específicos. Outra possibilidade na qual pode não haver seletores é ao se utilizar estritamente type: ExternalName.
Resumo
Expõe Pods ao tráfego externo
Tráfego de balanceamento de carga entre múltiplos Pods
Uso de rótulos labels
Um serviço Kubernetes é uma camada de abstração que define um conjunto lógico de Pods e habilita a exposição ao tráfego externo, balanceamento de carga e descoberta de serviço para esses Pods.
Serviços e Rótulos
Um serviço roteia tráfego entre um conjunto de Pods. Serviço é a abstração que permite pods morrerem e se replicarem no Kubernetes sem impactar sua aplicação. A descoberta e o roteamento entre Pods dependentes (tal como componentes frontend e backend dentro de uma aplicação) são controlados por serviços Kubernetes.
Serviços relacionam um conjunto de Pods usando Rótulos e seletores, um agrupamento primitivo que permite operações lógicas sobre objetos Kubernetes. Rótulos são pares de chave/valor anexados à objetos e podem ser usados de inúmeras formas:
Designar objetos para desenvolvimento, teste e produção
Adicionar tags de versão
Classificar um objeto usando tags
Rótulos podem ser anexados à objetos no momento de sua criação ou posteriormente. Eles podem ser modificados a qualquer tempo. Vamos agora expor sua aplicação usando um serviço e aplicar alguns rótulos.
2.5.1 - Executando múltiplas instâncias de seu aplicativo
Objetivos
Escalar uma aplicação usando kubectl.
Escalando uma aplicação
Nos módulos anteriores nós criamos um Deployment, e então o expusemos publicamente através de um serviço (Service). O Deployment criou apenas um único Pod para executar nossa aplicação. Quando o tráfego aumentar nós precisaremos escalar a aplicação para suportar a demanda de usuários.
O escalonamento é obtido pela mudança do número de réplicas em um Deployment
Resumo:
Escalando um Deployment
Você pode criar desde o início um Deployment com múltiplas instâncias usando o parâmetro --replicas para que o kubectl crie o comando de deployment
Escalar um Deployment garantirá que novos Pods serão criados e agendados para nós de processamento com recursos disponíveis. O escalonamento aumentará o número de Pods para o novo estado desejado. O Kubernetes também suporta o auto-escalonamento (autoscaling) de Pods, mas isso está fora do escopo deste tutorial. Escalar para zero também é possível, e isso terminará todos os Pods do Deployment especificado.
Executar múltiplas instâncias de uma aplicação irá requerer uma forma de distribuir o tráfego entre todas elas. Serviços possuem um balanceador de carga integrado que distribuirá o tráfego de rede entre todos os Pods de um Deployment exposto. Serviços irão monitorar continuamente os Pods em execução usando endpoints para garantir que o tráfego seja enviado apenas para Pods disponíveis.
O Escalonamento é obtido pela mudança do número de réplicas em um Deployment.
No momento em que múltiplas instâncias de uma aplicação estiverem em execução será possível realizar atualizações graduais no cluster sem que ocorra indisponibilidade. Nós cobriremos isso no próximo módulo. Agora, vamos ao terminal online e escalar nossa aplicação.
