Nota:

Este tutorial está disponible en un entorno de laboratorio gratuito proporcionado por Oracle.
Utiliza valores de ejemplo para credenciales, arrendamiento y compartimentos de Oracle Cloud Infrastructure. Al finalizar el laboratorio, sustituya estos valores por otros específicos de su entorno en la nube.

Uso de OCI Cloud Controller Manager en Oracle Cloud Native Environment

Introducción

El servicio LoadBalancer de Kubernetes expone el despliegue externamente mediante el equilibrador de carga de un proveedor de nube. Los servicios dependientes NodePort y ClusterIP, a los que se dirigen los equilibradores de carga externos, se crean automáticamente.

En este tutorial se muestra cómo desplegar el módulo Oracle Cloud Infrastructure Cloud Controller Manager (módulo OCI-CCM) en Oracle Cloud Native Environment para manejar solicitudes para un tipo de servicio LoadBalancer externo. El módulo Oracle Cloud Infrastructure Cloud Controller Manager utiliza el proyecto de código abierto oci-cloud-controller-manager, que es una implantación de Kubernetes Cloud Controller Manager (o un proveedor de nube fuera de árbol) para Oracle Cloud Infrastructure (OCI).

Objetivos

Despliegue del módulo Oracle Cloud Infrastructure Cloud Controller Manager
Crear un despliegue y un servicio LoadBalancer
Verificar el acceso mediante el servicio LoadBalancer

Requisitos

Un sistema Oracle Linux 8 o posterior con la siguiente configuración:

un usuario no root con privilegios sudo
Oracle Cloud Native Environment instalado y configurado

Configurar entorno de prácticas

Nota: Al utilizar el entorno de prácticas gratuitas, consulte Conceptos básicos de las prácticas de Oracle Linux para obtener información sobre la conexión y otras instrucciones de uso.

Información: el entorno de prácticas gratuitas despliega un entorno compacto de Oracle Cloud Native Environment en el nodo proporcionado y listo para crear entornos. Este despliegue tarda entre 8 y 10 minutos aproximadamente en terminar tras el lanzamiento. Por lo tanto, puede que desee salir mientras se ejecuta y, a continuación, volver para completar la práctica.

Si aún no está conectado, abra un terminal y conéctese mediante ssh al sistema ocne-node01.
```
ssh oracle@<ip_address_of_ol_node>
```

Confirme que el entorno está listo.

kubectl get pods -A

Resultado de ejemplo:

[oracle@ocne-node01 ~]$ kubectl get pods -A
NAMESPACE                      NAME                                             READY   STATUS    RESTARTS   AGE
externalip-validation-system   externalip-validation-webhook-7988bff847-8ws2v   1/1     Running   0          3m18s
kube-system                    coredns-7cbc77dbc7-qxqth                         1/1     Running   0          3m18s
kube-system                    coredns-7cbc77dbc7-r9bgj                         1/1     Running   0          3m18s
kube-system                    etcd-ocne-node01                                 1/1     Running   0          3m37s
kube-system                    kube-apiserver-ocne-node01                       1/1     Running   0          3m37s
kube-system                    kube-controller-manager-ocne-node01              1/1     Running   0          3m37s
kube-system                    kube-flannel-ds-vcwzn                            1/1     Running   0          3m18s
kube-system                    kube-proxy-7lx59                                 1/1     Running   0          3m18s
kube-system                    kube-scheduler-ocne-node01                       1/1     Running   0          3m37s
kubernetes-dashboard           kubernetes-dashboard-5d5d4947b5-7pffh            1/1     Running   0          3m18s

Abra el puerto HealthCheck en el firewall de Oracle Linux

Al utilizar un servicio LoadBalancer asociado a OCI-CCM, Kubernetes espera un punto final de comprobación del sistema disponible en el puerto 10256. Por lo tanto, kube-proxy crea un listener en este puerto para que el equilibrador de carga del proveedor de nube pueda verificar que kube-proxy está en buen estado. Esta comprobación del sistema determina cómo determina el equilibrador de carga qué nodos pueden tener el tráfico enrutado a ellos.

Defina las reglas de firewall para el nodo.
```
sudo firewall-cmd --add-port=10256/tcp --permanent
sudo firewall-cmd --reload
```
Al trabajar en un entorno de cluster, abra este puerto de firewall en todos los nodos de trabajador y plano de control.

Despliegue del módulo Oracle Cloud Infrastructure Cloud Controller Manager

Agregue los módulos helm y oci-ccm al archivo de configuración existente.
```
tee -a ~/myenvironment.yaml > /dev/null << 'EOF'
      - module: helm
        name: myhelm
        args:
          helm-kubernetes-module: mycluster
      - module: oci-ccm
        name: myoci
        oci-ccm-helm-module: myhelm
        oci-use-instance-principals: true
        oci-compartment:
        oci-vcn:
        oci-lb-subnet1:
EOF
```
El entorno de prácticas gratuitas utiliza políticas para permitir el uso de principales de instancia, lo que permite que las instancias sean actores (o principales) autorizados para realizar acciones en recursos de servicio.

El módulo Oracle Cloud Infrastructure Cloud Controller Manager utiliza la opción oci-use-instance-principals: true para la autenticación como valor por defecto.

Para obtener más información, consulte la documentación sobre el uso del equilibrador de carga de Oracle Cloud Infrastructure sobre cómo transferir información de credenciales relacionada con su arrendamiento de Oracle Cloud Infrastructure en lugar de utilizar los principales de instancia.
Agregue los OCID necesarios en el archivo de configuración.
1. Cambie de Terminal a escritorio de laboratorio gratuito.
2. Abra la página de detalles Luna Lab con el icono Luna Lab del escritorio de laboratorio libre.
3. Haga clic en el separador Oracle Cloud.
4. Desplácese hacia abajo y busque el OCID de compartimento y cópielo.
5. Cambie al terminal abierto anterior.
6. Abra el archivo de configuración con el editor de texto que desee. Aquí utilizaremos vi.
```
vi ~/myenvironment.yaml
```
7. Introduzca el modo de inserción vi escribiendo i.
8. Agregue el OCID de compartimento al final de la línea oci-compartment:.
  
  Nota: Debido a que es YAML, recuerde agregar un espacio antes de pegar el valor.
  Ejemplo:
  - module: oci-ccm name: myoci oci-ccm-helm-module: myhelm oci-use-instance-principals: true oci-compartment: ocid1.compartment.oc1..aaaaaaaamqicnhi7e6dj7fwtbiibfxxlzjpd3uf33f7a33gftzgpchrnuzna oci-vcn: oci-lb-subnet1:
9. Cambie a la página de detalles de Luna Lab y haga clic en el separador Recursos.
10. Busque vcn_ocid y cópielo.
11. Vuelva al terminal.
12. Agregue vcn_ocid al final de la línea oci-vcn:.
  
  Nota: Debido a que es YAML, recuerde agregar un espacio antes de pegar el valor.
  Ejemplo:
  - module: oci-ccm name: myoci oci-ccm-helm-module: myhelm oci-use-instance-principals: true oci-compartment: ocid1.compartment.oc1..aaaaaaaamqicnhi7e6dj7fwtbiibfxxlzjpd3uf33f7a33gftzgpchrnuzna oci-vcn: ocid1.vcn.oc1.eu-frankfurt-1.amaaaaaar5cqh7qam56nztotyx4xzhovuo7stl5dddlmdmubdcdam64sadka oci-lb-subnet1:
13. Vuelva a la página de detalles de Luna Lab.
14. Busque vcn_subnet_ocid y cópielo.
15. Vuelva al terminal.
16. Agregue vcn_subnet_ocid al final de la línea oci-lb-subnet1:.
  
  Nota: Debido a que es YAML, recuerde agregar un espacio antes de pegar el valor.
  Ejemplo:
  - module: oci-ccm name: myoci oci-ccm-helm-module: myhelm oci-use-instance-principals: true oci-compartment: ocid1.compartment.oc1..aaaaaaaamqicnhi7e6dj7fwtbiibfxxlzjpd3uf33f7a33gftzgpchrnuzna oci-vcn: ocid1.vcn.oc1.eu-frankfurt-1.amaaaaaar5cqh7qam56nztotyx4xzhovuo7stl5dddlmdmubdcdam64sadka oci-lb-subnet1: ocid1.subnet.oc1.eu-frankfurt-1.aaaaaaaazq3yaeofyv3azmnzm2cxrilnfhpmvhark7xw5u6eo3574mtbzswa
17. Guarde y cierre el archivo. Si utiliza vi, puede hacerlo escribiendo ESC, :wq! y ENTER.
IMPORTANTE: Asegúrese de que los OCID son correctos según su entorno. Si los valores son incorrectos, el módulo oci-ccm se instala, pero no podrá crear LoadBalancer cuando lo solicite el servicio.

Crear e instalar módulos.

olcnectl module create --config-file myenvironment.yaml
olcnectl module validate --config-file myenvironment.yaml
olcnectl module install --config-file myenvironment.yaml

Crear Despliegue y Servicio

Genere el archivo de configuración para el despliegue y el servicio.

tee echo-oci-lb.yml > /dev/null << 'EOF'
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: echo-deployment
  labels:
    app: echo1
spec:
  replicas: 2
  selector:
    matchLabels:
      app: echo1
  template:
    metadata:
      labels:
        app: echo1
    spec:
      containers:
      - name: echoserver
        image: k8s.gcr.io/echoserver:1.4
        ports:
        - containerPort: 80
---
kind: Service
apiVersion: v1
metadata:
  name: echo-lb-service
  annotations:
    service.beta.kubernetes.io/oci-load-balancer-security-list-management-mode: "None"
    service.beta.kubernetes.io/oci-load-balancer-internal: "false"
    service.beta.kubernetes.io/oci-load-balancer-shape: "10Mbps"
spec:
  selector:
    app: echo1
  type: LoadBalancer
  ports:
  - name: http
    port: 80
    targetPort: 8080
EOF

Crear despliegue y servicio.
```
kubectl create -f echo-oci-lb.yml
```

Verificación de la creación de despliegue y servicio

Obtenga una lista de despliegues.

kubectl get deployment

Resultado de ejemplo:

NAME              READY   UP-TO-DATE   AVAILABLE   AGE
echo-deployment   2/2     2            2           15s

Obtenga una lista de servicios.
```
kubectl get service
```
Resultado de ejemplo:
```
NAME              TYPE           CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE
echo-lb-service   LoadBalancer   10.108.35.18   <pending>     80:32162/TCP   23s
kubernetes        ClusterIP      10.96.0.1      <none>        443/TCP        13m
```
El valor 'pending' en EXTERNAL-IP para echo-lb-service existe hasta que el módulo Oracle Cloud Infrastructure Cloud Controller Manager crea e inicia LoadBalancer de OCI.

Repita la ejecución del comando kubectl get service hasta que la salida muestre la dirección EXTERNAL-IP. Debe aparecer entre 1 y 2 minutos, como máximo.

Los PORTS indican el puerto de recepción LoadBalancer de OCI (80) y el puerto de servicio secundario NodePort de Kubernetes generado automáticamente.
Obtenga una lista de puntos finales.
```
kubectl get endpoints
```
Resultado de ejemplo:
```
NAME              ENDPOINTS                         AGE
echo-lb-service   10.244.0.7:8080,10.244.0.8:8080   5m37s
kubernetes        10.0.0.140:6443                   18m
```
Un punto final es un recurso al que hace referencia un servicio de Kubernetes. El recurso realiza un seguimiento de las direcciones IP y los puertos de uno o más pods asignados dinámicamente durante la creación del servicio.

Verificar Aplicación

Prueba en un nodo del plano de control

Con un tipo de servicio LoadBalancer, la dirección IP y el puerto que se va a probar son la dirección IP EXTERNA y el puerto del servicio, que es el listener LoadBalancer de OCI. La solicitud se envía a continuación al backend LoadBalancer de OCI. El backend LoadBalancer de OCI enruta el tráfico al servicio NodePort secundario que se ejecuta en el nodo específico y, a continuación, al pod.

El uso de esta prueba específica requiere un nodo en el que exista kubectl.

Utilice JSONPath para asignar al listener LoadBalancer una variable.

LB=$(kubectl get svc -o jsonpath="{.status.loadBalancer.ingress[0].ip}" echo-lb-service)

Utilice JSONPath para asignar al puerto LoadBalancer una variable.

LBPORT=$(kubectl get svc -o jsonpath="{.spec.ports[0].port}" echo-lb-service)

Pruebe la aplicación.

curl -i -w "\n" $LB:$LBPORT

Resultado de ejemplo:

[oracle@ocne-node01 ~]$ curl -i -w "\n" $LB:$LBPORT
HTTP/1.1 200 OK
Server: nginx/1.10.0
Date: Wed, 06 Jul 2022 16:41:23 GMT
Content-Type: text/plain
Transfer-Encoding: chunked
Connection: keep-alive

CLIENT VALUES:
client_address=10.244.0.1
command=GET
real path=/
query=nil
request_version=1.1
request_uri=http://130.162.210.115:8080/

SERVER VALUES:
server_version=nginx: 1.10.0 - lua: 10001

HEADERS RECEIVED:
accept=*/*
host=10.0.0.138
user-agent=curl/7.61.1
BODY:
-no body in request-

La dirección IP de 130.162.210.115 que se muestra en la salida anterior es la dirección IP EXTERNA para LoadBalancer de OCI. Esta dirección es diferente en cada despliegue del ejercicio práctico. Verifique la dirección del equilibrador de carga. Para ello, inicie sesión en la consola de Cloud y vaya a Redes > Equilibradores de carga.

loadbalancer_ip (Fin de creación)

Prueba de Luna Desktop

El uso de esta prueba específica requiere un nodo fuera del cluster de Kubernetes.

Busque el valor EXTERNAL-IP para echo-lb-service.

kubectl get service

Resultado de ejemplo

[oracle@ocne-node01 ~]$ kubectl get service
NAME              TYPE           CLUSTER-IP     EXTERNAL-IP      PORT(S)        AGE
echo-lb-service   LoadBalancer   10.102.1.165   130.162.210.115  80:31468/TCP   32s
kubernetes        ClusterIP      10.96.0.1      <none>           443/TCP        11m

Con el explorador de Luna Desktop, abra un nuevo separador.
Introduzca el valor devuelto en la columna EXTERNAL-IP y pulse Intro.

NOTA: client_address se muestra en la salida es la dirección IP de la puerta de enlace asociada con la interfaz cni0. La interfaz cni0 gestiona las redes de cluster de Kubernetes como se describe en la documentación ascendente de Plugins de red.

Resumen

Ahora entendemos cómo crear un servicio LoadBalancer en Kubernetes. Compruebe las funciones adicionales de Oracle Cloud Native Environment y extráigalas mediante el módulo Oracle Cloud Infrastructure Cloud Controller Manager y las anotaciones de equilibrador de carga disponibles.

Para obtener más información

Más recursos de aprendizaje

Explore otros laboratorios en docs.oracle.com/learn o acceda a más contenido de aprendizaje gratuito en el canal YouTube de Oracle Learning. Además, visite education.oracle.com/learning-explorer para convertirse en un explorador de Oracle Learning.

Para obtener documentación sobre el producto, visite Oracle Help Center.

Título e Información de Copyright

Use OCI Cloud Controller Manager on Oracle Cloud Native Environment

F60051-02

August 2022