Como desenvolver uma aplicação Kubernetes com clusters locais e remotos

25 min de leitura
Patrocinado
Imagem de: Como desenvolver uma aplicação Kubernetes com clusters locais e remotos
Avatar do autor

Equipe TecMundo

@tec_mundo

Por Greg Dritschler

Conteúdo arquivado.

Data do arquivamento: 03/01/2020.

Este conteúdo não está mais sendo atualizado ou passando por manutenção. O conteúdo é fornecido “tal qual”. Considerando a rápida evolução da tecnologia, algumas informações, passos ou ilustrações podem ter sido modificados.

Como desenvolvedor, você quer reproduzir com rapidez no seu código-fonte localmente enquanto continua espelhando um ambiente de produção remoto o mais próximo possível. Este tutorial descreve como você pode configurar um cluster de Kubernetes de nó único local através do uso do Minikube e implementar nele uma aplicação. Depois, o tutorial mostra como você pode realizar os mesmos passos com o IBM Cloud Kubernetes Service no IBM Cloud. No final, você aprenderá a configurar um cluster local de nós múltiplos através do uso do kubeadm-dind-cluster, assim como também fazer isso remotamente, por meio do IBM Cloud Kubernetes Service.

Neste tutorial você aprenderá a executar as seguintes tarefas:

  • Criar um cluster de nó único usando o Minikube.

  • Criar um cluster de nós múltiplos usando o kubeadm-dind-cluster.

  • Criar clusters de nó único e múltiplos remotos usando o IBM Cloud Kubernetes Service.

  • Disponibilizar imagens aos seus clusters locais e remotos.

  • Acessar a aplicação em execução em seus clusters locais e remotos.

  • Modificar e implementar novamente a sua aplicação.

Requisitos

Antes de começar, você precisa instalar os CLIs necessários para criar e gerenciar os seus clusters de Kubernetes e implementar aplicações conteinerizadas no seu cluster. A IBM disponibiliza um instalador aqui, onde você pode encontrar essas ferramentas todas reunidas. Também há instruções de como as ferramentas podem ser obtidas de forma manual, caso você prefira.

Neste tutorial serão usadas as seguintes ferramentas:

  • git: um sistema de controle de versões que usaremos para obter a fonte de uma amostra de aplicação.

  • Docker: uma ferramenta que permite que desenvolvedores construam e executem uma aplicação como um container leve e portátil.

  • kubectl CLI: uma interface de linha de comando para a execução de comandos contra os clusters do Kubernetes.

  • ibmcloud CLI: uma interface de linha de comando para o gerenciamento de recursos no IBM Cloud.

Tempo estimado

Este tutorial deve levar aproximadamente 90 minutos para ser concluído.

1. Faça o download da aplicação-modelo

A aplicação usada neste tutorial consiste em um simples website de guestbook no qual os usuários podem postar mensagens. Você deve cloná-lo na sua workstation, uma vez que você deverá construí-lo localmente.

$ git clone https://github.com/IBM/guestbook

Para este tutorial especificamente, a aplicação é executada sem base de dados de apoio (ou seja, os dados são armazenados na memória).

2. Configure um cluster local de nó único usando o Minikube

O Minikube é uma ferramenta que permite executar o Kubernetes localmente com mais facilidade. O Minikube roda um cluster local de nó único do Kubernetes em um VM na sua workstation.

Instale o Minikube

Siga as instruções disponíveis aqui para instalar o Minikube na sua workstation.

Crie um cluster

Use o comando de inicialização do Minikube para começar um cluster. Essa ação cria uma máquina virtual na sua workstation e instala nela o Kubernetes. Note que se você estiver usando um monitor de máquina virtual diferente do VirtualBox, precisará passar uma instrução adicional --vm-driver para identificar o driver VM apropriado.

$ minikube start

Starting local Kubernetes v1.10.0 cluster...

Starting VM...

Downloading Minikube ISO

 160.27 MB / 160.27 MB  100.00% 0ss

Getting VM IP address...

Moving files into cluster...

Downloading kubelet v1.10.0

Downloading kubeadm v1.10.0

Finished Downloading kubelet v1.10.0

Finished Downloading kubeadm v1.10.0

Setting up certs...

Connecting to cluster...

Setting up kubeconfig...

Starting cluster components...

Kubectl is now configured to use the cluster.

Loading cached images from config file.

O Minikube configura o kubectl CLI para trabalhar com esse cluster. Você pode fazer a verificação utilizando um comando kubectl, como este:

$ kubectl get nodes

NAME       STATUS    ROLES     AGE       VERSION

minikube   Ready     master     1m       v1.10.0

Se você estiver trabalhando com diferentes clusters do Kubernetes e mudar o seu contexto do kubectl CLI para usar outro cluster, pode restaurar o contexto do Minikube usando o comando kubectl config use-context minikube.

Implemente a aplicação em seu cluster local

As implementações de Kubernetes são projetadas para obter imagens de um registro de container. No entanto, para o desenvolvimento local, você pode evitar a etapa extra de ter que enviar imagens para um registro apontando o seu docker CLI para o docker daemon rodando no Minikube.

$ eval $(minikube docker-env)

Se nesse momento você digitar docker ps, poderá ver todos os containers rodando no Minikube.

Observação: o efeito do comando eval é limitado à janela de comando atual. Caso você a feche e volte a abrir, será necessário repetir esse comando.

Agora, vamos seguir e construir a aplicação de guestbook:

$ cd guestbook/v1/guestbook

$ docker build -t guestbook:v1 .

Sending build context to Docker daemon   16.9kB

Step 1/13 : FROM golang as builder

latest: Pulling from library/golang

05d1a5232b46: Pull complete

5cee356eda6b: Pull complete

89d3385f0fd3: Pull complete

80ae6b477848: Pull complete

94ebfeaaddf3: Pull complete

dd697213ec59: Pull complete

715d1281dfe7: Pull complete

Digest: sha256:e8e4c4406217b415c506815d38e3f8ac6e05d0121b19f686c5af7eaadf96f081

Status: Downloaded newer image for golang:latest

 ---> fb7a47d8605b

Step 2/13 : RUN go get github.com/codegangsta/negroni

 ---> Running in 6867267a6832

Removing intermediate container 6867267a6832

 ---> 41cdd0ea4dee

Step 3/13 : RUN go get github.com/gorilla/mux github.com/xyproto/simpleredis

 ---> Running in 6f928ff5ec97

Removing intermediate container 6f928ff5ec97

 ---> 2c51f4a80903

Step 4/13 : COPY main.go .

 ---> 919077d83e2b

Step 5/13 : RUN go build main.go

 ---> Running in 5959c30f5c10

Removing intermediate container 5959c30f5c10

 ---> cbe90ddb11ed

Step 6/13 : FROM busybox:ubuntu-14.04

ubuntu-14.04: Pulling from library/busybox

a3ed95caeb02: Pull complete

300273678d06: Pull complete

Digest: sha256:7d3ce4e482101f0c484602dd6687c826bb8bef6295739088c58e84245845912e

Status: Downloaded newer image for busybox:ubuntu-14.04

 ---> d16744963217

Step 7/13 : COPY --from=builder /go//main /app/guestbook

 ---> 67c829eb8d1b

Step 8/13 : ADD public/index.html /app/public/index.html

 ---> e71b4653ca17

Step 9/13 : ADD public/script.js /app/public/script.js

 ---> 1e3e52db271f

Step 10/13 : ADD public/style.css /app/public/style.css

 ---> b5b7fcfa50ca

Step 11/13 : WORKDIR /app

Removing intermediate container b982fa510f1c

 ---> 15947fedd20a

Step 12/13 : CMD ["./guestbook"]

 ---> Running in 156afadc0459

Removing intermediate container 156afadc0459

 ---> 0205392b8cbf

Step 13/13 : EXPOSE 3000

 ---> Running in 448df38be767

Removing intermediate container 448df38be767

 ---> 9708eb5366ec

Successfully built 9708eb5366ec

Successfully tagged guestbook:v1

Note que a imagem recebeu a tag v1. Você não deve usar a tag mais recente, uma vez que isso pode levar o Kubernetes a tentar extrair a imagem de um registro público. Nós queremos que ele use a imagem armazenada localmente.

A imagem do guestbook agora estará presente no cluster do Minikube, o que significa que estamos prontos para rodá-lo:

$ kubectl run guestbook --image=guestbook:v1

deployment.apps/guestbook created

Nós podemos usar kubectl para verificar se o Kubernetes criou um pod contendo o nosso container e está rodando como deveria.

$ kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE

guestbook-6cd549c68f-d6qvw   1/1       Running   0          1m

Acesse a aplicação em execução

A aplicação de guestbook se encontra na porta 3000 dentro do pod. Pois, para que a aplicação se torne acessível externamente, é necessário criar um serviço de Kubernetes do tipo NodePort. O Kubernetes alocará uma porta na faixa 30000-32767, e o nó irá direcionar essa porta para a porta de destino do pod.

$ kubectl expose deployment guestbook --type=NodePort --port=3000

service/guestbook exposed

Para acessar o serviço, é necessário saber o endereço de IP da máquina virtual do Minikube e o número do nó da porta. O Minikube disponibiliza uma forma conveniente de se obter essa informação.

$ minikube service guestbook --url

http://192.168.99.104:30571

O endereço de IP e o número da porta em sua workstation poderão ser diferentes, obviamente. Você pode copiar e colar a url fornecida no seu navegador, e a aplicação do guestbook deve aparecer. Você também pode deixar a opção --url de lado, e o Minikube abrirá o seu navegador padrão com a url para você.

Modifique a aplicação

Vamos realizar uma simples modificação na aplicação e implementá-la novamente. Para isso, abra o arquivo public/script.js no vi ou no seu editor favorito. Modifique a função handleSubmission para que ela tenha uma instrução adicional para anexar a data ao valor de entrada, tal como você pode ver a seguir:

javascript

  var handleSubmission = function(e) {

    e.preventDefault();

    var entryValue = entryContentElement.val()

    if (entryValue.length > 0) {

      entryValue += " " + new Date();     // ADD THIS LINE

      entriesElement.append("

...

");

      $.getJSON("rpush/guestbook/" + entryValue, appendGuestbookEntries);

      entryContentElement.val("")

    }

    return false;

  }

Agora, reconstrua a imagem do docker e designe a ela uma nova tag:

$ docker build -t guestbook:v1.1 .

Depois de a imagem ser construída, será necessário informar ao Kubernetes para usar a nova imagem:

$ kubectl set image deployment/guestbook guestbook=guestbook:v1.1

deployment.extensions/guestbook image updated

Atualize a aplicação de guestbook no seu navegador. (É possível que você precise recarregar a página para obter o arquivo javascript atualizado.) Tente inserir algo no formulário e clique em “Submit”. Você deve ver o texto inserido, seguido da hora atual disposta na página.

3. Configure um cluster remoto de nó único usando o IBM Cloud Kubernetes Service

A partir de agora vamos continuar o desenvolvimento da aplicação no IBM Cloud. Caso você não tenha uma conta no IBM Cloud, pode se registrar aqui. As etapas nesta seção podem ser realizadas com uma conta Lite gratuita. (O cluster criado expirará depois de 1 mês.)

Faça o login no IBM Cloud CLI e informe as suas credenciais no IBM Cloud:

ibmcloud login

Observação: caso você possua uma ID associada, use o login ibmcloud --sso para acessar o IBM Cloud CLI.

Crie um cluster

Crie um cluster do Kubernetes:

$ ibmcloud ks cluster-create --name mycluster

The 'machine-type' flag was not specified. So a free cluster will be created.

Creating cluster...

OK

A criação do cluster continuará em segundo plano. Você pode checar o status da seguinte forma:

$ ibmcloud ks clusters

OK

Name        ID                                 State     Created         Workers   Location   Version

mycluster   ae7148d3c8e74d69b3ed94b6c5f02262   normal    4 minutes ago   1         hou02      1.10.7_1520

Se o estado do cluster estiver pendente, aguarde um momento e tente o comando novamente. Assim que o cluster for provisionado (ou seja, quando seu estado for normal), o cliente CLI kubectl do Kubernetes precisará ser configurado para dialogar com o cluster fornecido.

Execute o ibmcloud ks cluster-config mycluster, que cria um arquivo config na sua workstation:

$ ibmcloud ks cluster-config mycluster

OK

The configuration for mycluster was downloaded successfully. Export environment

variables to start using Kubernetes.

 

export KUBECONFIG=/home/gregd/.bluemix/plugins/container-service/clusters/mycluster/kube-config-hou02-mycluster.yml

Copie e execute a instrução exportada. Isso define a variável de ambiente KUBECONFIG para apontar para o arquivo kubectl config e faz com que o seu cliente kubectl trabalhe com o seu novo cluster do Kubernetes.

Você pode verificar essa ação inserindo o comando kubectl:

$ kubectl get nodes

NAME            STATUS    ROLES     AGE       VERSION

10.76.202.250   Ready         4m        v1.10.7+IKS

Implemente a aplicação no seu cluster remoto

Para que o Kubernetes possa extrair imagens para serem executadas no cluster, elas precisam estar armazenadas em um registro acessível. Você pode usar o IBM Cloud Kubernetes Service para enviar as imagens do Docker para o seu próprio registro privado.

Primeiro, adicione um namespace para criar o seu próprio repositório de imagens. (Um namespace consiste em um nome único para identificar o seu registro privado de imagens).

Substitua com o namespace de sua preferência.

$ ibmcloud cr namespace-add

O nome de registro criado terá o formato registry..bluemix.net/, onde depende da região onde a sua conta no IBM Cloud foi criada. Você pode descobrir essa informação por meio do comando ibmcloud cr region.

$ ibmcloud cr region

You are targeting region 'us-south', the registry is 'registry.ng.bluemix.net'.

 

OK

Antes que você possa inserir uma imagem no registro, é preciso executar o comando ibmcloud cr login para logar o seu Docker daemon local no IBM Cloud Container Registry.

ibmcloud cr login

Agora você pode identificar a nossa imagem local atual (que você construiu anteriormente enquanto a implantava no Minikube) para associá-la com o registro privado e enviá-la para o registro. Certifique-se de substituir e pelos valores apropriados.

$ docker tag guestbook:v1.1 registry..bluemix.net//guestbook:v1.1

$ docker push registry..bluemix.net//guestbook:v1.1

`

Para executar a aplicação, use o mesmo comando de execução do kubectl run, como antes, exceto que agora se refira à imagem no repositório local:

$ kubectl run guestbook --image=registry..bluemix.net//guestbook:v1.1

deployment.apps/guestbook created

Você pode usar o kubectl para verificar se o Kubernetes criou um pod contendo o nosso container e se ele está sendo executado:

$ kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE

guestbook-5986549d9-2f49g    1/1       Running   0          1m

Acesse o aplicativo em execução

A aplicação de guestbook se encontra na porta 3000 dentro do pod. Pois, para que a aplicação se torne acessível externamente, é necessário criar um serviço de Kubernetes do tipo NodePort. O Kubernetes alocará uma porta na faixa 30000-32767, e o nó irá direcionar essa porta para a porta de destino do pod.

$ kubectl expose deployment guestbook --type=NodePort --port=3000

service/guestbook exposed

Para acessar o serviço, você precisa saber o endereço de IP público do nó onde a aplicação se encontra em execução e o número da porta do nó que o Kubernetes designou para o serviço.

Para obter o endereço IP:

$ ibmcloud ks workers mycluster

OK

ID                                                 Public IP       Private IP    Machine Type   State    Status   Zone    Version

kube-hou02-paae7148d3c8e74d69b3ed94b6c5f02262-w1   173.193.75.82   10.76.202.250 free           normal   Ready    hou02   1.10.7_1520

Nesse caso, o IP público é o 173.193.75.82.

Para obter o número da porta do nó:

$ kubectl describe services/guestbook

Name:                     guestbook

Namespace:                default

Labels:                   run=guestbook

Annotations:             

Selector:                 run=guestbook

Type:                     NodePort

IP:                       172.21.192.189

Port:                       3000/TCP

TargetPort:               3000/TCP

NodePort:                   32146/TCP

Endpoints:                172.30.151.71:3000

Session Affinity:         None

External Traffic Policy:  Cluster

Events:                  

Nesse caso, o NodePort é o 32146.

Assim, nessa situação, a aplicação poderá ser acessada a partir de um navegador qualquer utilizando a URL http://173.193.75.82:32146/.

4. Configure um cluster local de nós múltiplos usando o kubeadm-dind-cluster

O desenvolvimento de aplicações mais avançadas pode requerer um cluster de nós múltiplos. Use o projeto kubernetes-sigs/kubeadm-dind-cluster para configurar um cluster do Kubernetes de nós múltiplos. Ele usa um "Docker in Docker" para simular nós múltiplos no Kubernetes em um único ambiente de máquina.

Instale o Kubeadm-dind-cluster

O kubeadm-dind-cluster é escrito para ser executado no Linux. Se você tem uma workstation Windows ou Mac, precisará configurar uma máquina virtual que rode o Linux. A abordagem recomendada é a de usar o VirtualBox e rodar uma máquina virtual convidada Ubuntu.

Você também precisará instalar o Docker na máquina virtual convidada.

O cluster kubeadm-dind-cluster fornecerá scripts pré-estabelecidos para configurar clusters do Kubernetes em vários níveis de versão. Este tutorial usa o script dind-cluster-v1.10.sh. Você pode obter o script aqui:

console

wget https://cdn.rawgit.com/kubernetes-sigs/kubeadm-dind-cluster/master/fixed/dind-cluster-v1.10.sh

Crie um cluster

Inicie um cluster executando o script dind-cluster-v1.10.sh com a opção up.

./dind-cluster-v1.10.sh up

Por padrão, o script criará um nó mestre do Kubernetes e dois nós de trabalho. Cada nó será executado dentro de um container separado do Docker.

O script configura o kubectl CLI para trabalhar com esse cluster. Primeiro, você deve adicionar o kubectl CLI ao seu caminho.

Depois, você pode verificar os nós do cluster introduzindo o comando kubectl get nodes:

$ export PATH="$HOME/.kubeadm-dind-cluster:$PATH"

$ kubectl get nodes

NAME          STATUS    ROLES     AGE       VERSION

kube-master   Ready     master    5m        v1.10.5

kube-node-1   Ready         3m        v1.10.5

kube-node-2   Ready         4m        v1.10.5

Implemente a aplicação no seu cluster

O cluster do Kubernetes precisa ser capaz de extrair imagens de algum lugar para que elas rodem no cluster. Com o Minikube, poderíamos indicar o Docker CLI para o Docker daemon do Minikube e evitar a necessidade de um registro. Entretanto, agora teremos vários Docker daemons que estarão rodando dentro de containers do Docker, e sincronizar imagens através deles é desafiador e pode gerar erros. Faz mais sentido trabalhar dentro do modelo de Kubernetes e usar um registro.

Veja como configurar o cluster para usar o registro privado criado usando o serviço IBM Cloud Kubernetes. Anteriormente, você aprendeu como criar o seu próprio repositório de imagens usando o ibmcloudCLI. Agora você precisará usar o ibmcloudCLI para criar um token para conceder acesso ao namespaces do seu IBM Cloud Container Registry:

$ ibmcloud cr token-add --description "token for kubeadm dind cluster access" --non-expiring --readwrite

Requesting a registry token...

 

Token identifier   58669dd6-3ddd-5c78-99f9-ad0a5aabd9ad

Token             

Ele cria um token que tem acesso de leitura e escrita a todos os namespaces que não expiram. O token real aparece no lugar de . Todo usuário em posse desse token pode enviar e extrair imagens de e para os seus namespaces.

A seguir, crie um segredo do Kubernetes para guardar o valor do token. Os segredos servem para guardar informações privadas. Você precisará substituir os seguintes valores neste comando:

  • \

  • Você pode descobrir isso executando o comando ibmcloud cr region.

$ ibmcloud cr region

You are targeting region 'us-south', the registry is 'registry.ng.bluemix.net'.

OK

Nesse caso, você substituiria o ng no endereço do registro.

  • \

  • Este é o emitido quando o token de registro acima é criado.

  • \

  • Você pode fornecer qualquer endereço de e-mail. Essa instrução é exigida pelo comando kubectl, mas não é usada para nada.

$ kubectl --namespace default create secret docker-registry registrysecret --docker-server=registry..bluemix.net --docker-username=token --docker-password= --docker-email=

secret "registrysecret" created

Por fim, você precisará que o Kubernetes use esse segredo quando extrair imagens. A maneira mais fácil de se fazer isso é adicionando-o à conta de serviço padrão do Kubernetes. Uma conta de serviço representa uma identidade para processos que rodam em um pod. Se um pod não possui uma conta de serviço atribuída, ele usará a conta de serviço padrão.

kubectl patch -n default serviceaccount/default -p '{"imagePullSecrets":[{"name": "registrysecret"}]}'

Esse comando diz ao Kubernetes para usar o registry secret que você criou para autenticar o seu registro privado quando ele precisar puxar uma imagem. Vamos tentar agora:

$ kubectl run guestbook --image=registry..bluemix.net//guestbook:v1.1

deployment.apps/guestbook created

Use o kubectl para verificar se o Kubernetes criou um pod contendo o nosso container e se ele está rodando:

$ kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE

guestbook-5986549d9-h5n74    1/1       Running   0          1m

Acesse a aplicação em execução

A aplicação de guestbook se encontra na porta 3000 dentro do pod. Pois, para que a aplicação se torne acessível externamente, é necessário criar um serviço de Kubernetes do tipo NodePort. O Kubernetes alocará uma porta na faixa 30000-32767, e o nó irá direcionar essa porta para a porta de destino do pod.

$ kubectl expose deployment guestbook --type=NodePort --port=3000

service/guestbook exposed

Para acessar o serviço, você precisará saber o endereço de IP de um dos nós de trabalho e o número da porta do nó que o Kubernetes designou para o serviço.

Obtendo o endereço IP:

$ docker exec -it kube-node-1 ip addr show eth0

15: eth0@if16: mtu 1500 qdisc noqueue state UP group default

    link/ether 02:42:ac:12:00:03 brd ff:ff:ff:ff:ff:ff link-netnsid 0

    inet 172.18.0.3/16 brd 172.18.255.255 scope global eth0

       valid_lft forever preferred_lft forever

Esse comando exibe a interface eth0 no container kube-node-1. O endereço de IP do container aparece após inet e, nesse caso, ele é o 172.18.0.3.

Obtendo o número da porta do nó:

$ kubectl describe services/guestbook

Name:                     guestbook

Namespace:                default

Labels:                   run=guestbook

Annotations:             

Selector:                 run=guestbook

Type:                     NodePort

IP:                       10.100.222.15

Port:                       3000/TCP

TargetPort:               3000/TCP

NodePort:                   32345/TCP

Endpoints:                10.244.2.3:3000

Session Affinity:         None

External Traffic Policy:  Cluster

Events:                  

Nesse caso, o NodePort é o 32345.

Portanto, nessa situação, a aplicação pode ser acessada a partir de um navegador rodando no host Linux usando a URL http://172.18.0.3:32345/. Note que, embora você esteja usando o endereço IP do kube-node-1, a aplicação não precisa estar rodando naquele nó para que a URL funcione. Cada nó faz um direcionamento do NodePort para o Serviço.

Escale o número de pods

Naturalmente, a razão para se ter um cluster é aumentar a capacidade e melhorar a disponibilidade, colocando cópias de uma aplicação em vários nós. O Kubernetes chama essas cópias de “réplicas”.

Agora, diga ao Kubernetes que queremos duas réplicas da aplicação:

$ kubectl scale --replicas=2 deployment guestbook

deployment.extensions "guestbook" scaled

O Kubernetes trabalhará em segundo plano para iniciar um pod adicional para que o número total de pods seja igual a 2.

Você pode verificar o status dessa ação executando o comando kubectl get deployments:

$ kubectl get deployments

NAME        DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE

guestbook   2         2         2            2           10m

Você também pode conferir o status dos pods e em quais nós eles estão rodando:

$ kubectl get pods -o wide

NAME                        READY     STATUS    RESTARTS   AGE       IP           NODE

guestbook-5986549d9-8dnhb   1/1       Running   0          7s        10.244.3.5   kube-node-2

guestbook-5986549d9-qtnmg   1/1       Running   0          7s        10.244.2.5   kube-node-1

Após os dois pods estarem em execução, tente o seguinte exercício. Abra a aplicação em um navegador qualquer, digite algumas mensagens e feche o navegador. Repita essa ação algumas vezes. Você verá alterações na exibição de mensagens convidadas anteriores porque o navegador estará se conectando a um ou outro nó e as mensagens serão mantidas na memória. (Você deve fechar o navegador e abri-lo novamente para forçar uma nova conexão. Caso contrário, ele permanecerá conectado ao mesmo nó).

É claro que uma aplicação real de guestbook manteria as mensagens armazenadas em backup. O IBM Cloud Kubernetes Service Lab mostrará a você como adicionar um banco de dados Redis ao guestbook.

5. Configure um cluster de nós múltiplos remoto usando o IBM Cloud Kubernetes Service

Agora confira a continuação do desenvolvimento de nossas aplicações em um cluster de nós múltiplos no IBM Cloud.

Para criar um cluster de nós múltiplos (referido como um cluster padrão), você deverá ter uma conta Pré-paga ou de Assinatura. Visite https://cloud.ibm.com/docs/account/index.html#accounts para mais informações sobre os diferentes tipos de conta.

Acesse o IBM Cloud CLI e digite as suas credenciais do IBM Cloud quando solicitado.

ibmcloud login

Observação: se você possuir uma ID associada, use o login ibmcloud --sso para fazer o login no IBM Cloud CLI.

Crie um cluster

É recomendável utilizar o dashboard do IBM Cloud para criar um cluster padrão, uma vez que ele ajudará a guiá-lo através das opções de configuração e exibirá o seu custo estimado.

  • Clique no botão Login no canto superior direito e siga as instruções de login para acessar a sua conta.

  • Clique na aba Containers no lado esquerdo da janela e, depois, selecione a opção Kubernetes Service.

  • Clique no botão Create.

  • Preencha o formulário que aparece. Primeiro, selecione um local para o seu cluster, pois isso definirá as outras opções. Em seguida, escolha uma zona dentro do local e um tipo de máquina. Defina o número de nós de trabalho como sendo 2. Dê um nome ao seu cluster; neste tutorial usaremos "myStandardCluster".

  • Reveja a estimativa de custo na parte direita da janela.

  • Clique no botão Create Cluster.

A criação do cluster continuará em segundo plano. Você poderá verificar o status do processo da seguinte forma:

$ ibmcloud ks clusters

OK

Name                ID                                 State     Created          Workers   Location    Version

myStandardCluster   fc5514ef25ac44da9924ff2309020bb3   normal    12 minutes ago   2         Dallas     1.10.7_1520

Se o estado do cluster estiver pendente, aguarde um momento e tente o comando novamente. Uma vez que o cluster esteja provisionado (onde o estado será normal), o cliente kubernetes CLI kubectl precisará ser configurado para dialogar com o cluster provisionado. Execute o ibmcloud ks cluster-config myStandardCluster, ação esta que criará um arquivo de configuração na sua workstation:

$ ibmcloud ks cluster-config myStandardCluster

OK

The configuration for mycluster was downloaded successfully. Export environment

variables to start using Kubernetes.

 

export KUBECONFIG=/home/gregd/.bluemix/plugins/container-service/clusters/myStandardCluster/kube-config-hou02-myStandardCluster.yml

Copie a instrução de exportação e execute-a. Essa ação definirá a variável de ambiente KUBECONFIG que será direcionada para o arquivo de configuração kubectl. Isso fará o seu cliente kubectl trabalhar com o seu novo cluster do Kubernetes.

Você pode verificar isso digitando um comando kubectl:

$ kubectl get nodes

NAME            STATUS    ROLES     AGE       VERSION

10.177.184.185   Ready         2m        v1.10.7+IKS

10.177.184.220   Ready         2m        v1.10.7+IKS

Implemente a aplicação em seu cluster remoto

Note que, se você criou o seu registro no plano trial ou Lite, ele permanecerá nesse plano e estará sujeito a certas cotas. Visite https://cloud.ibm.com/docs/services/Registry?topic=registry-registry_overview para obter mais informações sobre as cotas de registro e como atualizar o seu plano de serviço de registro.

Vamos continuar a usar a aplicação de guestbook que inserimos em um registro privado. O seu novo cluster terá acesso automático a esse registro.

$ kubectl run guestbook --image=registry..bluemix.net//guestbook:v1.1

deployment.apps/guestbook created

Você pode utilizar o kubectl para verificar se o Kubernetes criou um pod contendo o nosso container e se este se encontra em execução.

$ kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE

guestbook-7b9f8cf696-fg8v8   1/1       Running   0          1m

Acesse a aplicação em execução

A aplicação de guestbook se encontra na porta 3000 dentro do pod. Pois, para que a aplicação se torne acessível externamente, é necessário criar um serviço de Kubernetes do tipo NodePort. O Kubernetes alocará uma porta na faixa 30000-32767, e o nó irá direcionar essa porta para a porta de destino do pod.

$ kubectl expose deployment guestbook --type=NodePort --port=3000

service/guestbook exposed

(Note que com um cluster padrão você também poderá fazer uso de um serviço LoadBalancer ou de um recurso Ingress. Entretanto, esses conceitos estão além do escopo deste tutorial).

Para acessar o serviço, é necessário saber o endereço de IP de um dos nós de trabalho e o número da porta do nó que o Kubernetes designou para o serviço.

Obtenha o endereço IP da seguinte forma:

$ ibmcloud ks workers myStandardCluster

OK

ID                                                 Public IP        Private IP       Machine Type        State    Status   Zone    Version

kube-dal10-crfc5514ef25ac44da9924ff2309020bb3-w1   169.47.252.42    10.177.184.220   u2c.2x4.encrypted   normal   Ready    dal10   1.10.7_1520

kube-dal10-crfc5514ef25ac44da9924ff2309020bb3-w2   169.48.165.242   10.177.184.185   u2c.2x4.encrypted   normal   Ready    dal10   1.10.7_1520

Você pode usar o endereço de IP público de qualquer um dos nós. Cada nó faz o direcionamento do NodePort para o Serviço.

Obtenha o número da porta do nó da seguinte forma:

$ kubectl describe services/guestbook

Name:                     guestbook

Namespace:                default

Labels:                   run=guestbook

Annotations:             

Selector:                 run=guestbook

Type:                     NodePort

IP:                       172.21.210.103

Port:                       3000/TCP

TargetPort:               3000/TCP

NodePort:                   31096/TCP

Endpoints:                172.30.108.133:3000

Session Affinity:         None

External Traffic Policy:  Cluster

Events:                  

Nesse caso, o NodePort é o 31096, portanto a aplicação poderá ser acessada a partir de um navegador qualquer usando a URL http://169.47.252.42:31096/ ou a http://169.48.165.242:31096.

Escale o número de pods

Podemos dizer ao Kubernetes que queremos duas réplicas, assim como fizemos no cluster local de nós múltiplos:

$ kubectl scale --replicas=2 deployment guestbook

deployment.extensions "guestbook" scaled

O Kubernetes trabalhará em segundo plano para iniciar um pod adicional para que o número total de pods seja igual a 2. Você pode verificar o status dessa ação executando o comando kubectl get deployments.

$ kubectl get deployments

NAME        DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE

guestbook   2         2         2            2           10m

Você também pode verificar o status dos pods e em quais nós eles estão rodando, da seguinte maneira.

$ kubectl get pods -o wide

NAME                         READY     STATUS    RESTARTS   AGE       IP               NODE

guestbook-7b9f8cf696-dzgcb   1/1       Running   0          14s       172.30.58.204    10.177.184.185

guestbook-7b9f8cf696-hvrc7   1/1       Running   0          14s       172.30.108.136   10.177.184.220

Você pode repetir o exercício anterior para se conectar ao pod que está em execução em cada nó.

Limpeza

Depois de completar este tutorial, você poderá apagar os recursos do Kubernetes criados em seus clusters, caso não precise mais deles:

  • Defina o contexto do Kubectl CLI para o cluster que pretende limpar.

Para o Minikube, use kubectl config use-context minikube.

Para o IBM Cloud Kubernetes Service, use ibmcloud ks cluster-config mycluster ou ibmcloud ks cluster-config myStandardCluster e copie e cole a configuração da variável de ambiente KUBECONFIG.

  • Apague a implementação e seu serviço digitando os seguintes comandos.

$ kubectl delete deployment guestbook

$ kubectl delete service guestbook

Para excluir o seu cluster do Minikube, digite os seguintes comandos:

$ minikube stop

$ minikube delete

Para excluir o seu kubeadm-dind-cluster, digite os seguintes comandos:

./dind-cluster-v1.10.sh down

./dind-cluster-v1.10.sh clean

Para deletar o seu cluster do IBM Cloud Kubernetes Service, digite os seguintes comandos:

ibmcloud ks cluster-rm myCluster

ibmcloud ks cluster-rm myStandardCluster 

Resumo

Parabéns! Você realizou a iteração do código-fonte da sua aplicação localmente com o Minikube e replicou os passos na nuvem.

Para saber mais sobre o IBM Cloud Kubernetes Service, considere a possibilidade de conferir o Catálogo de Serviços do Kubernetes.

...

Quer ler mais conteúdo especializado de programação? Conheça a IBM Blue Profile e tenha acesso a matérias exclusivas, novas jornadas de conhecimento e testes personalizados. Confira agora mesmo, consiga as badges e dê um upgrade na sua carreira!

Como desenvolver uma aplicação Kubernetes com clusters locais e remotos