Configuración del primer clúster en Virtual Private Cloud (VPC)

Nube privada virtual

Cree un clúster de Red Hat® OpenShift® on IBM Cloud® en Virtual Private Cloud (VPC).

Red Hat OpenShift on IBM Cloud te ofrece todas las ventajas de una oferta gestionada para tu entorno de infraestructura de clústeres, al tiempo que utiliza las herramientas y el catálogo de Red Hat OpenShift, que se ejecutan en Red Hat Enterprise Linux, para las implementaciones de tus aplicaciones.
VPC le proporciona la seguridad de un entorno de nube privado con la escalabilidad dinámica de una nube pública. VPC utiliza la versión siguiente de Red Hat OpenShift on IBM Cloud proveedores de infraestructura, con un grupo seleccionado de API v2, CLI y funciones de consola.
Este tutorial crea un cluster en VPC usando comandos CLI de ibmcloud. Como alternativa, puede utilizar un módulo Terraform de código abierto y preparado para empresas para desplegar un clúster OpenShift en una infraestructura VPC. Puede explorar más módulos en el registro de módulos de Terraform IBM.

Audiencia

Esta guía de aprendizaje está pensada para los administradores que crean un clúster en Red Hat OpenShift on IBM Cloud en un entorno de cálculo de VPC por primera vez.

Objetivos

En las lecciones de la guía de aprendizaje puede crear un clúster de Red Hat OpenShift on IBM Cloud en Virtual Private Cloud (VPC). A continuación, se accede a los componentes integrados de Red Hat OpenShift, se implementa una aplicación en un proyecto de Red Hat OpenShift y se expone la aplicación mediante un equilibrador de carga de VPC para que los usuarios externos puedan acceder al servicio.

Qué obtendrá

En este tutorial, creará los siguientes recursos. Hay pasos opcionales para suprimir estos recursos si no desea conservarlos después de completar la guía de aprendizaje.

Un clúster de VPC
Una app Hello World simple desplegada en el clúster
Un equilibrador de carga de VPC para exponer la app

Requisitos previos

Complete los siguientes pasos de requisito previo para configurar permisos y el entorno de línea de mandatos.

Permisos

Si eres el titular de la cuenta, ya dispones de los permisos necesarios para crear un clúster y puedes pasar al siguiente paso. De lo contrario, solicite al propietario de la cuenta que configure la clave de API y le asigne los permisos de usuario mínimos en IBM Cloud IAM.

Herramientas de línea de mandatos

Para acceder rápidamente a tus recursos desde la línea comando, prueba el IBM Cloud Shell. De lo contrario, configure el entorno de línea de mandatos local siguiendo los pasos siguientes.

Instale la CLI de IBM Cloud (ibmcloud), el plugin Kubernetes Service (ibmcloud oc) y el plugin IBM Cloud Container Registry (ibmcloud cr).
Instale las CLI de Red Hat OpenShift (oc) y de Kubernetes (kubectl).
Para trabajar con VPC, instale el plugin infrastructure-service. El prefijo para ejecutar mandatos es ibmcloud is.

    ibmcloud plugin install infrastructure-service
    ```
4. Actualice el plugin de Kubernetes Service a la última versión.
```sh {: pre}
    ibmcloud plugin update kubernetes-service
    ```

Creación de un clúster en una VPC

Cree un entorno de IBM Cloud Virtual Private Cloud (VPC). A continuación, cree un clúster de Red Hat OpenShift on IBM Cloud en la infraestructura de VPC. Para obtener más información acerca de VPC, consulte Iniciación a Virtual Private Cloud.

Inicie una sesión en la cuenta, el grupo de recursos y la región de IBM Cloud donde desea crear el entorno de VPC. La VPC debe configurarse en la misma región metropolitana multizona en la que desee crear su clúster. En esta guía de aprendizaje se crea una VPC en us-south. Para ver otras regiones admitidas, consulte Áreas metropolitanas multizona para clústeres de VPC. Si dispone de una identificación federada, incluya la opción --sso.
```
ibmcloud login -r us-south [-g <resource_group>] [--sso]
```

Cree una VPC para el clúster. Para obtener más información, consulte la documentación sobre cómo crear una VPC en la consola o la CLI.

Cree una VPC llamada myvpc y anote el ID en la salida. Las VPC proporcionan un entorno aislado para que las cargas de trabajo se ejecuten dentro de la nube pública. Puede utilizar la misma VPC para varios clústeres, por ejemplo si desea tener distintos clústeres que alberguen microservicios separados que se tengan que comunicar entre sí. Si desea separar los clústeres, por ejemplo por departamentos, puede crear una VPC para cada clúster.

    ibmcloud is vpc-create myvpc
    ```
2. Cree una pasarela pública y anote el **ID** de la salida. En el paso siguiente, conecte la pasarela pública a una subred de VPC, de modo que los nodos trabajadores puedan comunicarse en la red pública. Los componentes predeterminados de Red Hat OpenShift, como la consola web y OperatorHub, tienen que acceder a la red pública. Si omite este paso, debe estar conectado a la red privada de VPC, por ejemplo a través de una conexión VPN, para acceder a la consola web de Red Hat OpenShift o para acceder al clúster con mandatos `kubectl`.
```sh {: pre}
    ibmcloud is public-gateway-create gateway-us-south-1 <vpc_ID> us-south-1
    ```
3. Cree una subred para la VPC y anote su **ID**. Tenga en cuenta la siguiente información cuando cree la subred de VPC:
    *  **Zonas**: debe tener una subred de VPC para cada zona del clúster. Las zonas disponibles dependen de la región en la que haya creado la VPC. Para consultar las zonas de la región, ejecute `ibmcloud is zones`.
    *  **Direcciones IP**: las subredes de VPC proporcionan direcciones IP privadas para los nodos trabajadores y los servicios de equilibrador de carga en el clúster, por lo tanto asegúrese de [crear una subred con suficientes direcciones IP](/docs/openshift?topic=openshift-vpc-subnets#vpc_basics_subnets), como por ejemplo 256. Después, ya no puede cambiar el número de direcciones IP que tiene una subred de VPC.
    *  **Pasarelas públicas**: incluya la pasarela pública que ha creado anteriormente. Debe tener una pasarela pública para cada zona del clúster.

        ```sh {: pre}
        ibmcloud is subnet-create mysubnet1 VPC_ID --zone us-south-1 --ipv4-address-count 256 --pgw GATEWAY_ID
        ```
Si tiene varias zonas, repita estos pasos para cada zona.
{: tip}

Cree una instancia de IBM Cloud Object Storage estándar para realizar una copia de seguridad del registro interno en el clúster. En la salida, anote el ID de la instancia.
```
ibmcloud resource service-instance-create myvpc-cos cloud-object-storage standard global
```
Cree un clúster en la VPC en la misma zona que la subred. El siguiente comando crea un clúster de versión 4.21 en Dallas con la configuración mínima de 2 nodos de trabajo que tienen al menos 4 núcleos y 16 GB de memoria, de modo que se puedan implementar los componentes predeterminados de Red Hat OpenShift. Para obtener más información sobre las opciones del mandato, consulte la documentación de referencia de la 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
```
Obtenga una lista de los detalles del clúster. Revise el Estado del clúster, compruebe el Subdominio de Ingress y anote el URL maestro. El proceso de creación del clúster puede tardar un rato en completarse. Después de que el estado del clúster muestre Normal, la red del clúster y los componentes de Ingress tardan unos 10 minutos más en desplegarse y actualizar el dominio de clúster que utiliza para la consola web de Red Hat OpenShift y otras rutas. Antes de continuar, espere a que el clúster esté preparado comprobando que el Subdominio de Ingress siga un patrón de <cluster_name>-<globally_unique_account_HASH>-0001.<region>.containers.appdomain.cloud.
```
ibmcloud oc cluster get --cluster myvpc-cluster
```
Añádase como usuario al clúster de Red Hat OpenShift estableciendo el contexto de clúster.
```
ibmcloud oc cluster config --cluster myvpc-cluster --admin
```
En el navegador, vaya a la dirección de su URL maestro y añada /console. Por ejemplo, https://c0.containers.cloud.ibm.com:23652/console. Si tiene tiempo, puede explorar las distintas áreas de la consola web de Red Hat OpenShift.
En la barra de menús de la consola web Red Hat OpenShift, haz clic en tu perfil IAM#user.name@email.com > Copiar comando de inicio de sesión. Visualice y copie el comando de token oc login en la línea de comandos para autenticar usando la CLI.

Guarde el URL del nodo maestro del clúster para acceder a la consola de Red Hat OpenShift posteriormente. En futuras sesiones, puede omitir el paso cluster config y copiar el mandato de inicio de sesión desde la consola.
Compruebe que los mandatos oc se ejecutan correctamente con el clúster comprobando la versión.
```
oc version
```
Salida de ejemplo
```
Client Version: v4.21.0
Kubernetes Version: v1.35.7.2
```
Si no puede realizar operaciones que requieran permisos de administrador como, por ejemplo, listar todos los nodos de trabajador o los pods de un clúster, descargue los certificados TLS y los archivos de permisos para el administrador del clúster ejecutando el mandato ibmcloud oc cluster config --cluster myvpc-cluster --admin.

Despliegue de una app en el clúster

Despliegue rápidamente una nueva app de ejemplo que solo está disponible para las solicitudes procedentes de dentro del clúster.

Crea un proyecto Red Hat OpenShift para tu aplicación Hello World.
```
oc new-project hello-world
```
Compila la aplicación de ejemplo a partir del código fuente. Con el mandato de Red Hat OpenShift new-app, puede hacer referencia a un directorio en un repositorio remoto que contenga el Dockerfile y el código de la app para crear la imagen. El comando crea la imagen, la almacena en el registro local de Docker y crea las configuraciones de implementación de la aplicación (dc) y los servicios (svc). Para obtener más información sobre cómo crear nuevas aplicaciones, consulta la documentación de Red Hat OpenShift.
```
oc new-app --name hello-world https://github.com/IBM/container-service-getting-started-wt --context-dir="Lab 1"
```

Compruebe que se han creado los componentes de la app Hello World de ejemplo.

Obtenga una lista de los servicios hello-world y anote el nombre del servicio. Hasta ahora, su app solo escucha el tráfico en estas direcciones IP de clúster internas. En la siguiente lección, creará un equilibrador de carga para el servicio para que el equilibrador de carga pueda reenviar solicitudes de tráfico externas a la app.

    oc get svc -n hello-world
    ```
    Salida de ejemplo
    ```sh {: screen}
    NAME          TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)    AGE
    hello-world   ClusterIP   172.21.xxx.xxx   <none>       8080/TCP   31m
    ```
2. Obtenga una lista de los pods. Los pods que contienen `build` en su nombre son trabajos que se han **completado** como parte del proceso de compilación de la nueva app. Asegúrese de que el estado del pod **hello-world** es **Running**.
```sh {: pre}
    oc get pods -n hello-world
    ```
    Salida de ejemplo
    ```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
    ```

Configuración de un equilibrador de carga de VPC para exponer la app de forma pública

Configure un equilibrador de carga de VPC para exponer la app a solicitudes externas en la red pública.

Cuando se crea un servicio LoadBalancer de Kubernetes en el clúster, se crea automáticamente un equilibrador de carga de VPC en la VPC fuera del clúster. El equilibrador de carga de VPC es multizona y direcciona las solicitudes de la app a través de los NodePorts privados que se abren automáticamente en los nodos trabajadores. En el diagrama siguiente se muestra cómo un usuario accede al servicio de una app a través del equilibrador de carga de VPC, aunque el nodo trabajador solo está conectado a una subred privada.

Cree un servicio LoadBalancer de Kubernetes en el clúster para exponer de forma pública la app hello world.

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

Salida de ejemplo

service "hw-lb-svc" exposed

Más información acerca de los parámetros de exposición
Parámetro	Descripción
`expose`	Exponga un recurso de Kubernetes, como por ejemplo un despliegue, como un servicio de modo que los usuarios puedan acceder al recurso mediante el nombre de host del equilibrador de carga de VPC.
`dc/<hello-world-deployment>`	El tipo de recurso y el nombre del recurso para exponer con este servicio.
`--name=<hello-world-service>`	El nombre del servicio.
`--type=LoadBalancer`	El tipo de servicio a crear. En esta lección, creará un servicio `LoadBalancer`.
`--port=<8080>`	El puerto en el que el servicio escucha el tráfico de la red externa.
`--target-port=<8080>`	El puerto en el que la app escucha y a la que el servicio dirige el tráfico de red de entrada. En este ejemplo, `target-port` es el mismo que `port`, pero otras app que cree pueden utilizar otro puerto.
`-n <hello-world>`	El espacio de nombres en el que está el despliegue.

Verifique que el servicio LoadBalancer de Kubernetes se ha creado correctamente en el clúster. Cuando se crea el servicio LoadBalancer de Kubernetes, se crea automáticamente un equilibrador de carga de VPC. El equilibrador de carga de VPC asigna un nombre de host al servicio de Kubernetes LoadBalancer que puede ver en el campo LoadBalancer Ingress de la salida de la CLI. En VPC, a los servicios del clúster se les asigna un nombre de host porque la dirección IP externa del servicio no es estable. El equilibrador de carga de VPC tarda unos minutos en suministrarse en la VPC. Hasta que el equilibrador de carga de VPC esté listo, no puede acceder al servicio de Kubernetes LoadBalancer a través de su nombre de host.

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

Ejemplo de salida de 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 que el equilibrador de carga de VPC se ha creado correctamente en la VPC. En la salida, verifique que el equilibrador de carga de VPC tiene como estatus de suministro (Provision Status) el valor active y como estatus operativo (Operating Status) el valor online.

El equilibrador de carga de VPC se denomina con el formato kube-<cluster_ID>-<kubernetes_lb_service_UID>. Para ver el ID de clúster, ejecute ibmcloud oc cluster get --cluster CLUSTER_NAME. Para ver el UID del servicio LoadBalancer de Kubernetes, ejecute kubectl get svc hw-lb-svc -o yaml y busque el campo metadata.uid en la salida.
```
ibmcloud is load-balancers
```
En la siguiente salida de CLI de ejemplo, se crea el equilibrador de carga de VPC denominado kube-bsaucubd07dhl66e4tgg-1f4f408ce6d2485499bcbdec0fa2d306 para el servicio LoadBalancer de Kubernetes:
```
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
```
Envíe una solicitud a la app mediante cURL con el nombre de host y el puerto del servicio LoadBalancer de ubernetes asignado por el equilibrador de carga de VPC que ha encontrado en el paso 2. Ejemplo:
```
curl 1234abcd-us-south.lb.appdomain.cloud:8080
```
Salida de ejemplo
```
Hello world from hello-world-deployment-5fd7787c79-sl9hn! Your app is up and running in a cluster!
```

Opcional: para limpiar los recursos que ha creado en esta lección, puede utilizar las etiquetas asignadas a cada app.

Obtenga una lista de los recursos de cada app del proyecto hello-world.

    oc get all -l app=hello-world -o name -n hello-world
    ```
    Salida de ejemplo
    ```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. Suprima todos los recursos que ha creado.
```sh {: pre}
    oc delete all -l app=hello-world -n hello-world
    ```

¿Qué hacer a continuación?

Ahora que tienes un clúster de VPC, aprenda más sobre lo que puede hacer.

¿Necesita ayuda, tiene preguntas o desea escribir comentarios sobre los clústeres de VPC? Intente publicar en el canal de Slack.