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
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
$ ibmcloud cr namespace-add
O nome de registro criado terá o formato registry.
$ 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
$ docker tag guestbook:v1.1 registry.
$ docker push registry.
`
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.
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:
TargetPort: 3000/TCP
NodePort:
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
kube-node-2 Ready
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
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.
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.
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:
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:
TargetPort: 3000/TCP
NodePort:
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
10.177.184.220 Ready
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.
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:
TargetPort: 3000/TCP
NodePort:
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!
Categorias
