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

Nuvem Privada Virtual

Crie um cluster do Red Hat® OpenShift® on IBM Cloud® em seu Virtual Private Cloud (VPC).

Red Hat OpenShift on IBM Cloud oferece todas as vantagens de uma solução gerenciada para o ambiente de infraestrutura de clusters, ao mesmo tempo em que utiliza as ferramentas e o catálogo do Red Hat OpenShift, que rodam no Red Hat Enterprise Linux, para as implantações de seus aplicativos.
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 Red Hat OpenShift on IBM Cloud provedores de infraestrutura, com um grupo de funcionalidades da API, da CLI e do console da v2.
Este tutorial cria um cluster em VPC usando comandos da CLI do ibmcloud. Como alternativa, você pode usar um módulo Terraform de código aberto e pronto para uso empresarial para implantar um cluster OpenShift na infraestrutura VPC. Você pode explorar mais módulos no registro de Módulos do Terraform IBM.

Público

Este tutorial destina-se a administradores que estão criando um cluster no Red Hat OpenShift on IBM Cloud no cálculo do VPC pela primeira vez.

Objetivos

Nas lições do tutorial, você cria um cluster do Red Hat OpenShift on IBM Cloud em um Virtual Private Cloud (VPC). Em seguida, você acessa os componentes integrados do Red Hat OpenShift, implanta um aplicativo em um projeto do Red Hat OpenShift e expõe o aplicativo por meio de um balanceador de carga da VPC, para que usuários externos possam acessar o serviço.

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 acessar rapidamente seus recursos a partir da linha de comando, experimente o IBM Cloud Shell. Caso contrário, configure seu ambiente de linha de comandos local concluindo as etapas a seguir.

Instale a CLI do IBM Cloud (ibmcloud), o plug-in do Kubernetes Service (ibmcloud oc) e o plug-in do IBM Cloud Container Registry (ibmcloud cr).
Instale as CLIs Red Hat OpenShift (oc) e o Kubernetes (kubectl).
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.
```sh {: pre}
    ibmcloud plugin update kubernetes-service
    ```

Criar um cluster em uma VPC

Crie um ambiente de Nuvem particular virtual (VPC) do IBM Cloud. Em seguida, crie um cluster Red Hat OpenShift on IBM Cloud na infraestrutura de VPC. Para obter mais informações sobre a VPC, consulte Introdução à Nuvem particular virtual.

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]
```

Crie uma VPC para seu cluster. Para obter mais informações, consulte os docs para criar um VPC no console ou na CLI.

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 um gateway público e anote o **ID** na saída. Na próxima etapa, você anexa o gateway público a uma sub-rede da VPC, de modo que seus nós do trabalhador possam se comunicar na rede pública. Os componentes padrão do Red Hat OpenShift, como o console da web e o OperatorHub, requerem acesso à rede pública. Se você ignorar esta etapa, em vez disso, esteja conectado à sua rede privada de VPC, como por meio de uma conexão de VPN, para acessar o console da web do Red Hat OpenShift ou acesse seu cluster com comandos `kubectl`.
```sh {: pre}
    ibmcloud is public-gateway-create gateway-us-south-1 <vpc_ID> us-south-1
    ```
3. 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 em que 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/openshift?topic=openshift-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**: inclua o gateway público que você criou anteriormente. Deve-se ter um gateway público para cada zona no cluster.

        ```sh {: pre}
        ibmcloud is subnet-create mysubnet1 VPC_ID --zone us-south-1 --ipv4-address-count 256 --pgw GATEWAY_ID
        ```
Se você tiver várias zonas, repita essas etapas para cada zona.
{: tip}

Crie uma instância padrão do IBM Cloud Object Storage para fazer backup do registro interno em seu cluster. Na saída, anote o ID da instância.
```
ibmcloud resource service-instance-create myvpc-cos cloud-object-storage standard global
```
Crie um cluster em seu VPC na mesma zona da sub-rede. O comando a seguir cria um cluster do 4.21 em Dallas com a configuração mínima de 2 nós de trabalho que possuem pelo menos 4 núcleos e 16 GB de memória, para que os componentes padrão do Red Hat OpenShift possam ser implantados. Para obter mais informações sobre as opções de comandos, consulte os docs de referência da CLI cluster create vpc-gen2.
```
ibmcloud oc cluster create vpc-gen2 --name myvpc-cluster --zone us-south-1 --version 4.21_openshift --flavor bx2.4x16 --workers 2 [--operating-system REDHAT_8_64] --vpc-id VPC_ID --subnet-id VPC_SUBNET_ID --cos-instance COS_CRN --disable-outbound-traffic-protection
```
Liste os detalhes do cluster. Revise o Estado do cluster, verifique o Subdomínio do Ingress e anote a URL principal. A criação do cluster pode levar algum tempo para ser concluída. Após o estado do cluster mostrar Normal, os componentes de rede e de ingresso do cluster levam cerca de 10 minutos a mais para implementar e atualizar o domínio do cluster que você usa para o console da web do Red Hat OpenShift e outras rotas. Antes de continuar, aguarde até que o cluster esteja pronto verificando se o Subdomínio de ingresso segue um padrão de <cluster_name>-<globally_unique_account_HASH>-0001.<region>.containers.appdomain.cloud.
```
ibmcloud oc cluster get --cluster myvpc-cluster
```
Inclua-se como um usuário no cluster Red Hat OpenShift configurando o contexto do cluster.
```
ibmcloud oc cluster config --cluster myvpc-cluster --admin
```
Em seu navegador, navegue para o endereço de sua URL principal e anexe /console. Por exemplo, https://c0.containers.cloud.ibm.com:23652/console. Se o tempo permitir, será possível explorar as diferentes áreas do console da web do Red Hat OpenShift.
Na barra de menus do console da web do Red Hat OpenShift, clique no seu perfil IAM#user.name@email.com > Copiar comando de login. Exiba e copie o comando do token oc login em sua linha de comando para autenticação usando a CLI

Salve sua URL principal do cluster para acessar o console do Red Hat OpenShift posteriormente. Em sessões futuras, será possível ignorar a etapa cluster config e copiar o comando de login do console como alternativa.
Verifique se os comandos oc são executados corretamente com seu cluster verificando a versão.
```
oc version
```
Exemplo de saída
```
Client Version: v4.21.0
Kubernetes Version: v1.35.7.2
```
Se você não puder executar operações que requerem permissões de Administrador, como listar todos os nós do trabalhador ou pods em um cluster, faça download dos certificados TLS e arquivos de permissão para o administrador do cluster executando o comando ibmcloud oc cluster config --cluster myvpc-cluster --admin.

Implementar um app em seu cluster

Implemente rapidamente um novo app de amostra que está disponível para solicitações de dentro do cluster apenas.

Crie um projeto “ Red Hat OpenShift ” para seu aplicativo “Hello World”.
```
oc new-project hello-world
```
Compile o aplicativo de exemplo a partir do código-fonte. Com o comando Red Hat OpenShiftnew-app , você pode indicar um diretório em um repositório remoto que contenha o Dockerfile e o código do aplicativo para compilar sua imagem. O comando compila a imagem, armazena-a no registro local Docker e cria as configurações de implantação do aplicativo (dc) e os serviços (svc). Para obter mais informações sobre como criar novos aplicativos, consulte a documentação do Red Hat OpenShift.
```
oc new-app --name hello-world https://github.com/IBM/container-service-getting-started-wt --context-dir="Lab 1"
```

Verifique se os componentes do app Hello World de amostra são criados.

Liste os serviços hello-world e anote o nome do serviço. Até o momento, seu app atende o tráfego nesses endereços IP do cluster interno apenas. Na próxima lição, você cria um balanceador de carga para o serviço para que o balanceador de carga possa encaminar solicitações de tráfego externo para o app.

    oc get svc -n hello-world
    ```
    Exemplo de saída
    ```sh {: screen}
    NAME          TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)    AGE
    hello-world   ClusterIP   172.21.xxx.xxx   <none>       8080/TCP   31m
    ```
2. Liste os pods. Os pods com `build` no nome são tarefas **Concluídas** como parte do novo processo de construção do app. Certifique-se de que o status do pod **hello-world** seja **Em execução**.
```sh {: pre}
    oc get pods -n hello-world
    ```
    Exemplo de saída
    ```sh {: screen}
    NAME                  READY     STATUS             RESTARTS   AGE
    hello-world-1-9cv7d   1/1       Running            0          30m
    hello-world-1-build   0/1       Completed          0          31m
    hello-world-1-deploy  0/1       Completed          0          31m
    ```

Configurar um balanceador de carga de VPC para expor seu app publicamente

Configure um balanceador de carga de VPC para expor seu app a solicitações externas na rede pública.

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

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

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

Exemplo de saída

service "hw-lb-svc" exposed

Mais sobre os parâmetros de exposição
Parâmetro	Descrição
`expose`	Exponha um recurso do Kubernetes, por exemplo, uma implementação, como um serviço para que os usuários possam acessar o recurso usando o nome do host do balanceador de carga da VPC.
`dc/<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 de serviço a ser criado. Nesta lição, você criará 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.
`-n <hello-world>`	O namespace no qual sua implementação está.

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 seu serviço LoadBalancer do Kubernetes que pode ser visto no campo Ingress do LoadBalancer da sua saída da CLI. Na VPC, os serviços em seu cluster são designados a um nome do host porque o endereço IP externo para o serviço não é estável. 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.

oc describe service hw-lb-svc -n hello-world

Exemplo de saída da CLI:

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

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 oc 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
```
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. Exemplo:
```
curl 1234abcd-us-south.lb.appdomain.cloud:8080
```
Exemplo de saída
```
Hello world from hello-world-deployment-5fd7787c79-sl9hn! Your app is up and running in a cluster!
```

Opcional: para limpar os recursos que você criou nesta lição, é possível usar os rótulos que são designados a cada app.

Liste todos os recursos para cada app no projeto hello-world.

    oc get all -l app=hello-world -o name -n hello-world
    ```
    Exemplo de saída
    ```sh {: screen}
    pod/hello-world-1-dh2ff
    replicationcontroller/hello-world-1
    service/hello-world
    deploymentconfig.apps.openshift.io/hello-world
    buildconfig.build.openshift.io/hello-world
    build.build.openshift.io/hello-world-1
    imagestream.image.openshift.io/hello-world
    imagestream.image.openshift.io/node
    ```
2. Exclua todos os recursos que você criou.
```sh {: pre}
    oc delete all -l app=hello-world -n hello-world
    ```

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.