Configurando seu primeiro cluster em seu Virtual Private Cloud (VPC)

Crie um cluster do IBM Cloud® Kubernetes Service em sua nuvem privada virtual (VPC).

Com os clusters do IBM Cloud Kubernetes Service na VPC, você pode criar seu cluster na próxima geração da plataforma IBM Cloud, em sua Nuvem Privada Virtual. A VPC fornece a segurança de um ambiente de nuvem particular com a escalabilidade dinâmica de uma nuvem pública. A VPC usa a próxima versão de IBM Cloud Kubernetes Service provedores de infraestrutura, com um grupo de funcionalidades da API, da CLI e do console da v2. É possível criar apenas clusters padrão para VPC.

Público

Este tutorial é para administradores que estão criando um cluster no IBM Cloud Kubernetes Service na VPC pela primeira vez.

Objetivos

Nas lições do tutorial, você cria um cluster IBM Cloud Kubernetes Service em um VPC (Virtual Private Cloud). Em seguida, você implementará um app e o exporá publicamente usando um balanceador de carga.

O que você vai conseguir

Neste tutorial, você criará os seguintes recursos. Há etapas opcionais para excluir esses recursos se você não desejar mantê-los após concluir o tutorial.

  • Um cluster VPC
  • Um app Hello World simples implementado no cluster
  • Um balanceador de carga do VPC para expor seu app

Pré-requisitos

Conclua as etapas de pré-requisito a seguir para configurar permissões e o ambiente da linha de comandos.

Permissões
Se você for o titular da conta, já possui as permissões necessárias para criar um cluster e pode prosseguir para a próxima etapa. Caso contrário, solicite ao proprietário da conta que configure a chave de API e designe a você as permissões mínimas do usuário no IBM Cloud IAM.
Ferramentas de Linha de Comandos
Para acesso rápido aos seus recursos a partir da linha de comando, tente o IBM Cloud Shell. Caso contrário, configure seu ambiente de linha de comandos local concluindo as etapas a seguir.
  1. Instale a CLI do IBM Cloud (ibmcloud), o plug-in do Kubernetes Service (ibmcloud ks) e o plug-in do IBM Cloud Container Registry (ibmcloud cr).
  2. Instale as CLIs Red Hat OpenShift (oc) e o Kubernetes (kubectl).
  3. Para trabalhar com a VPC, instale o plug-in infrastructure-service. O prefixo para a execução de comandos é ibmcloud is.
    ibmcloud plugin install infrastructure-service
  4. Atualize seu plug-in do Kubernetes Service para a versão mais recente.
    ibmcloud plugin update kubernetes-service
  5. Certifique-se de que a versão do kubectl corresponda à versão do Kubernetes de seu cluster de VPC. Este tutorial cria um cluster que executa a versão 1.35.

Criar um cluster na VPC

Crie um cluster IBM Cloud Kubernetes Service em seu ambiente do IBM Cloud Virtual Private Cloud (VPC). Para obter mais informações sobre a VPC, consulte Introdução à Nuvem particular virtual.

  1. Efetue login na conta, grupo de recursos e região do IBM Cloud na qual você deseja criar seu ambiente de VPC. O VPC deve ser configurado na mesma região metropolitana multizona em que você deseja criar seu cluster. Neste tutorial, você cria uma VPC em us-south. Para ver outras regiões suportadas, consulte Áreas metropolitanas multizona para clusters VPC. Se você tiver uma identificação federada, inclua a opção “ --sso ”.
    ibmcloud login -r us-south [-g <resource_group>] [--sso]
  2. Crie uma VPC para seu cluster. Para obter mais informações, consulte os docs para criar um VPC no console ou na CLI.
    1. Crie um VPC chamado myvpc e anote o ID mostrado na saída. As VPCs fornecem um ambiente isolado para que suas cargas de trabalho sejam executadas na nuvem pública. É possível usar a mesma VPC para diversos clusters, por exemplo, ao planejar que clusters diferentes hospedem microsserviços que precisam se comunicar entre si. Para separar seus clusters, por exemplo, para departamentos diferentes, é possível criar uma VPC para cada cluster.
        ibmcloud is vpc-create myvpc
    ```
2. Crie uma sub-rede para seu VPC e anote seu **ID**. Considere as informações a seguir ao criar a sub-rede da VPC:
    - **Zonas**: deve-se ter uma sub-rede da VPC para cada zona no cluster. As zonas disponíveis dependem da região metropolitana na qual você criou a VPC. Para listar zonas disponíveis na região, execute `ibmcloud is zones`.
    - **Endereços IP**: as sub-redes de VPC fornecem endereços IP privados para seus serviços de nós do trabalhador e de balanceador de carga em seu cluster, portanto, certifique-se de [criar uma sub-rede com endereços IP suficientes](/docs/containers?topic=containers-vpc-subnets#vpc_basics_subnets), como 256. O número de endereços IP contidos em uma sub-rede de VPC não pode ser alterado posteriormente.
    - **Gateways públicos**: não é necessário se conectar a um gateway público para concluir este tutorial. Em vez disso, é possível manter os nós do trabalhador isolados do acesso público usando balanceadores de carga da VPC para expor cargas de trabalho com segurança. Será possível conectar um gateway público se os nós do trabalhador precisarem acessar uma URL pública.

```sh {: pre}
    ibmcloud is subnet-create mysubnet1 VPC_ID --zone us-south-1 --ipv4-address-count 256
    ```
  3. Crie um cluster em seu VPC na mesma zona da sub-rede. Por padrão, seu cluster é criado com um terminal em serviço de nuvem pública e de nuvem privada. É possível usar o terminal em serviço de nuvem pública para acessar o principal do Kubernetes, por exemplo, para executar comandos kubectl por meio de sua máquina local. Seus nós do trabalhador podem se comunicar com o principal no terminal em serviço de nuvem privada. Para obter mais informações sobre as opções de comandos, consulte os docs de referência da CLI cluster create vpc-gen2.
    ibmcloud ks cluster create vpc-gen2 --name myvpc-cluster --zone us-south-1 --version 1.35 --flavor bx2.2x8 --workers 1 --vpc-id VPC_ID --subnet-id VPC_SUBNET_ID
  4. Verifique o estado de seu cluster. O provisionamento do cluster pode levar alguns minutos para ser concluído.
    1. Verifique se o Estado do cluster está normal.
        ibmcloud ks cluster ls --provider vpc-gen2
    ```
2. Faça download dos arquivos de configuração do Kubernetes.
```sh {: pre}
    ibmcloud ks cluster config --cluster myvpc-cluster
    ```
3. Verifique se os comandos `kubectl` são executados adequadamente com seu cluster verificando a versão do servidor de CLI do Kubernetes.
```sh {: pre}
    kubectl version  --short
    ```
    Saída de exemplo
    ```sh {: screen}
    Client Version: 1.35
    Server Version: 1.35+IKS
    ```

Implementar um app disponível privadamente

Crie uma implementação do Kubernetes para implementar uma única instância de app como um pod em seu nó do trabalhador no cluster de VPC.

  1. Clone o código-fonte do app Hello World para o diretório inicial do usuário. O repositório contém versões diferentes de um app semelhante em pastas iniciadas com Lab. Cada versão contém os arquivos a seguir:

    • Dockerfile: as definições de construção para a imagem.
    • app.js: o app Hello World.
    • package.json: metadados sobre o app.
    git clone https://github.com/IBM/container-service-getting-started-wt.git

  2. Acesse o diretório Lab 1.

    cd 'container-service-getting-started-wt/Lab 1'

  3. Use um namespace de registro existente ou crie um, como vpc-gen2.

    ibmcloud cr namespace-list

    ibmcloud cr namespace-add vpc-gen2

  4. Construa uma imagem do Docker que inclua os arquivos de app do diretório Lab 1.

    Use caracteres alfanuméricos minúsculos ou sublinhados (_) somente no nome da imagem. Não esqueça o ponto (.) no final do comando. O ponto indica ao Docker para verificar dentro do diretório atual para o Dockerfile e construir artefatos para construir a imagem.

    docker build -t us.icr.io/<namespace>/hello-world:1 .

    Quando a construção estiver completa, verifique se você vê a mensagem de êxito a seguir:

    => exporting to image                                                                           0.0s
=> => exporting layers                                                                          0.0s
=> => writing image sha256:3ca1eb1d0998f738b552d4c435329edf731fe59e427555b78ba2fb54f2017906     0.0s
=> => naming to <region>.icr.io/<namespace>/hello-world:1                                       0.0s

  5. Efetue login no IBM Cloud Container Registry.

    ibmcloud cr login

  6. Envie por push a imagem para o namespace IBM Cloud Container Registry criado. Se for necessário mudar o app no futuro, repita estas etapas para criar outra versão da imagem. Nota: saiba mais sobre proteção de suas informações pessoais quando você trabalhar com imagens de contêiner.

    docker push us.icr.io/<namespace>/hello-world:1

  7. Crie uma implementação para seu app. As implementações são usadas para gerenciar pods, que incluem instâncias conteinerizadas de um app. O comando a seguir implementa o app em um único pod. Para os propósitos deste tutorial, a implementação é denominada hello-world-deployment, mas é possível fornecer à implementação qualquer nome que você desejar.

    kubectl create deployment hello-world-deployment --image=us.icr.io/vpc-gen2/hello-world:1

    Saída de exemplo

    deployment.apps/hello-world-deployment created

    Saiba mais sobre como proteger suas informações pessoais quando trabalhar com recursos do Kubernetes.

  8. Torne o app acessível expondo a implementação como um serviço NodePort. Como seus nós do trabalhador da VPC estão conectados somente a uma sub-rede privada, o NodePort recebe apenas um endereço IP privado e não é exposto na rede pública. Outros serviços executados na rede privada podem acessar seu app usando o endereço IP privado do serviço NodePort.

    kubectl expose deployment/hello-world-deployment --type=NodePort --name=hello-world-service --port=8080 --target-port=8080

    Saída de exemplo

    service/hello-world-service exposed
    Informações sobre as opções de comando.
    Parâmetro Descrição
    expose Exponha um recurso do Kubernetes, como uma implementação, como um serviço do Kubernetes para que os usuários possam acessar o recurso usando o endereço IP do serviço.
    deployment/*<hello-world-deployment>* O tipo de recurso e o nome do recurso a serem expostos com este serviço.
    --name=*<hello-world-service>* O nome do serviço.
    --type=NodePort O tipo de serviço a ser criado. Nesta lição, você cria um serviço NodePort. Na lição a seguir, você cria um serviço LoadBalancer.
    --port=*<8080>* A porta na qual o serviço atende o tráfego de rede externa.
    --target-port=*<8080>* A porta na qual o app atende e para a qual o serviço direciona o tráfego de rede recebido. Nesse exemplo, target-port é o mesmo que port, mas outros apps criados podem usar uma porta diferente.

  9. Agora que todo o trabalho de implementação foi concluído, é possível testar seu app dentro do cluster. Obtenha os detalhes para formar o endereço IP privado que pode ser usado para acessar seu app.

    1. Obtenha informações sobre o serviço para ver qual NodePort foi designado. Os NodePorts são designados aleatoriamente quando são gerados com o comando expose, mas dentro de 30000-32767. Neste exemplo, o NodePort é 30872.
        kubectl describe service hello-world-service
    ```
    Saída de exemplo

    ```sh {: screen}
    NAME:                   hello-world-service
    Namespace:              default
    Labels:                 run=hello-world-deployment
    Selector:               run=hello-world-deployment
    Type:                   NodePort
    IP:                     10.xxx.xx.xxx
    Port:                   <unset> 8080/TCP
    NodePort:               <unset> 30872/TCP
    Endpoints:              172.30.xxx.xxx:8080
    Session Affinity:       None
    No events.
    ```
2. Liste os pods que executam seu app e anote o nome do pod.
```sh {: pre}
    kubectl get pods
    ```
    Saída de exemplo
    ```sh {: screen}
    NAME                                     READY     STATUS        RESTARTS   AGE
    hello-world-deployment-d99cddb45-lmj2v   1/1       Running       0          2d
    ```
3. Descreva seu pod para descobrir em qual nó do trabalhador o pod está em execução. Na saída de exemplo, o nó do trabalhador no qual o pod é executado é **10.xxx.xx.xxx**.
```sh {: pre}
    kubectl describe pod hello-world-deployment-d99cddb45-lmj2v
    ```
    Saída de exemplo

    ```sh {: screen}
    NAME:               hello-world-deployment-d99cddb45-lmj2v
    Namespace:          default
    Priority:           0
    PriorityClassName:  <none>
    Node:               10.xxx.xx.xxx/10.xxx.xx.xxx
    Start Time:         Mon, 22 Apr 20122 12:40:48 -0400
    Labels:             pod-template-hash=d99cddb45
                        run=hello-world-deployment
    Annotations:        kubernetes.io/psp=ibm-privileged-psp
    Status:             Running
    IP:                 172.30.xxx.xxx
    ...
    ```

  10. Efetue login no pod para que seja possível fazer uma solicitação para seu app dentro do cluster.

    kubectl exec -it hello-world-deployment-d99cddb45-lmj2v /bin/sh

  11. Faça uma solicitação para o serviço NodePort usando o endereço IP privado do nó do trabalhador e a porta de nó recuperada anteriormente.

    wget -O - 10.xxx.xx.xxx:30872

    Saída de exemplo

    Connecting to 10.xxx.xx.xxx:30872 (10.xxx.xx.xxx:30872)
Hello world from hello-world-deployment-d99cddb45-lmj2v! Your app is up and running in a cluster!
-                    100% |*****************************************************************************************|    88   0:00:00 ETA

    Para fechar sua sessão de pod, insira exit.

Configurar um Load Balancer for VPC para expor seu app de publicamente

Configure um balanceador de carga da VPC para expor seu app na rede pública.

Ao criar um serviço LoadBalancer do Kubernetes em seu cluster, um balanceador de carga para VPC é criado automaticamente em seu VPC fora do cluster. O balanceador de carga tem várias zonas e roteia solicitações para o app por meio dos NodePorts privados abertos automaticamente nos nós do trabalhador. O diagrama a seguir ilustra como um usuário acessa um serviço do app por meio do balanceador de carga, embora seu nó do trabalhador esteja conectado a apenas uma sub-rede privada.

Balanceamento de carga da VPC para um cluster.
Balanceamento de carga da VPC para um cluster

  1. Crie um serviço LoadBalancer do Kubernetes em seu cluster para expor publicamente o app hello world.

    kubectl expose deployment/hello-world-deployment --type=LoadBalancer --name=hw-lb-svc  --port=8080 --target-port=8080

    Saída de exemplo

    service "hw-lb-svc" exposed
    Informações sobre as opções de comando.
    Parâmetro Descrição
    expose Exponha um recurso do Kubernetes, como uma implementação, como um serviço do Kubernetes para que os usuários possam acessar o recurso usando o endereço IP do serviço.
    deployment/*<hello-world-deployment>* O tipo de recurso e o nome do recurso a serem expostos com este serviço.
    --name=*<hello-world-service>* O nome do serviço.
    --type=LoadBalancer O tipo do serviço do Kubernetes a ser criado. Nesta lição, você cria um serviço LoadBalancer.
    --port=*<8080>* A porta na qual o serviço atende o tráfego de rede externa.
    --target-port=*<8080>* A porta na qual o app atende e para a qual o serviço direciona o tráfego de rede recebido. Nesse exemplo, target-port é o mesmo que port, mas outros apps criados podem usar uma porta diferente.

  2. Verifique se o serviço LoadBalancer do Kubernetes foi criado com êxito em seu cluster. Ao criar o serviço LoadBalancer do Kubernetes, um balanceador de carga de VPC é criado automaticamente para você. O balanceador de carga de VPC designa um nome do host ao serviço LoadBalancer do Kubernetes que pode ser visto no campo Ingress do LoadBalancer da saída da CLI. O provisionamento do balanceador de carga da VPC leva alguns minutos para ser concluído em seu VPC. Até que o balanceador de carga VPC esteja pronto, não será possível acessar o serviço LoadBalancer do Kubernetes utilizando seu nome de host.

    kubectl describe service hw-lb-svc

    Saída da CLI de exemplo

    NAME:                     hw-lb-svc
Namespace:                default
Labels:                   app=hello-world-deployment
Annotations:              <none>
Selector:                 app=hello-world-deployment
Type:                     LoadBalancer
IP:                       172.21.xxx.xxx
LoadBalancer Ingress:     1234abcd-us-south.lb.appdomain.cloud
Port:                     <unset> 8080/TCP
TargetPort:               8080/TCP
NodePort:                 <unset> 32040/TCP
Endpoints:
Session Affinity:         None
External Traffic Policy:  Cluster
Events:
    Type    Reason                Age   From                Message
    ----    ------                ----  ----                -------
    Normal  EnsuringLoadBalancer  1m    service-controller  Ensuring load balancer
    Normal  EnsuredLoadBalancer   1m    service-controller  Ensured load balancer

  3. Verifique se o balanceador de carga VPC foi criado com êxito na VPC. Na saída, verifique se o balanceador de carga de VPC tem um Status de provisão de active e um Status de operação de online.

    O nome do balanceador de carga VPC é definido no formato kube-<cluster_ID>-<kubernetes_lb_service_UID>. Para ver seu ID de cluster, execute ibmcloud ks cluster get --cluster CLUSTER_NAME. Para ver o UID do serviço LoadBalancer do Kubernetes, execute kubectl get svc hw-lb-svc -o yaml e procure o campo metadata.uid na saída.

    ibmcloud is load-balancers

    Na saída da CLI de exemplo a seguir, o balanceador de carga de VPC denominado kube-bsaucubd07dhl66e4tgg-1f4f408ce6d2485499bcbdec0fa2d306 é criado para o serviço de Kubernetes LoadBalancer:

    ID                                          Name                                                         Family        Subnets               Is public   Provision status   Operating status   Resource group
r006-d044af9b-92bf-4047-8f77-a7b86efcb923   kube-bsaucubd07dhl66e4tgg-1f4f408ce6d2485499bcbdec0fa2d306   Application   mysubnet-us-south-3   true        active             online             default

  4. Envie uma solicitação ao seu app enrolando o nome do host e a porta do serviço LoadBalancer de Kubernetes, que é designado pelo balanceador de carga do VPC que você localizou na etapa 2.

    curl 1234abcd-us-south.lb.appdomain.cloud:8080

    Saída de exemplo

    Hello world from hello-world-deployment-5fd7787c79-sl9hn! Your app is up and running in a cluster!

O que vem a seguir?

Agora que você tem um cluster de VPC, saiba mais sobre o que pode ser feito.

Precisa de ajuda, tem perguntas ou deseja fornecer feedback sobre clusters VPC? Tente postar no Canal Slack.