Nota:

Creación de un cluster de Container Engine for Kubernetes (OKE) con el proveedor OCI para Pulumi

Introducción

Oracle Cloud Infrastructure (OCI) Container Engine for Kubernetes (OKE) es un servicio totalmente gestionado, escalable y con alta disponibilidad que puede utilizar para desplegar las aplicaciones en contenedores en la nube. Especifique los recursos informáticos que necesitan sus aplicaciones y OKE los aprovisionará en OCI en un arrendamiento existente. OKE utiliza Kubernetes para automatizar el despliegue, la ampliación y la gestión de aplicaciones en contenedores en clusters de hosts.

Pulumi es una infraestructura moderna como plataforma de código que permite utilizar lenguajes de programación y herramientas conocidas para crear, desplegar y gestionar una infraestructura en la nube. El proveedor de Oracle Cloud Infrastructure (OCI) para Pulumi se puede utilizar para aprovisionar cualquiera de los recursos disponibles en OCI. El proveedor de OCI debe estar configurado con credenciales para desplegar y actualizar recursos en OCI.

En este tutorial se proporciona una visión general sobre cómo gestionar la infraestructura como código mediante el proveedor de OCI para Pulumi. Aprenderá a aprovisionar un cluster de OKE mediante Python como lenguaje de desarrollo.

Objetivo

Requisitos

Tarea 1: Crear una pila de Pulumi

Cada programa Pulumi se despliega en una pila. Una pila es una instancia aislada e independientemente configurable de un programa Pulumi. Las pilas se suelen utilizar para indicar diferentes fases de desarrollo (como desarrollo, temporal y producción) o ramas de funciones (como función-x-dev).

Crear un directorio de inicio

Cree un directorio de inicio para la pila donde almacenaremos un archivo de estado y el código fuente de la pila.

$> mkdir pulumi-oke-py && cd pulumi-oke-py   (on Linux or MacOS )

Creación de un repositorio de estado

Pulumi almacena el estado de su pila en Pulumi Service o en un archivo de estado local para rastrear los cambios en su infraestructura. En este tutorial, lo almacenaremos en un archivo de estado local.

Opción 1. Crear un directorio de archivos de estado local

Esta opción creará un directorio local para almacenar estados. Para este tutorial, se configurará la opción 1.

$> mkdir oci-stack-statefile (on Linux or MacOS )
$> pulumi login file://oci-stack-statefile

Opción 2. Estado de la tienda en el servicio gratuito de Pulumi

Pulumi ofrece un servicio para almacenar el estado de la pila. Existen varias capas, desde la libertad hasta la organización.

$> pulumi login

Nota: Para este tutorial solo guardaremos el archivo de estado localmente, como se describe en la opción 1. La opción 2 sólo es para información adicional.

Crear una nueva pila de Python

  1. Confirme qué servicio y usuario está utilizando ejecutando el comando whoami.

    $> pulumi whoami -v

User: <user>
Organizations:
Backend URL: file://oci-stack-statefile

  2. Al crear una pila, Pulumi necesita entender qué tipo de plantilla utilizar para su proyecto.

    Nota:

    • A medida que vamos a codificar en Python, debe seleccionar una plantilla de Python transfiriendo el nombre de la plantilla "python" después de las palabras clave "pulumi new".
    • Pulumi CLI le solicitará un nombre de su proyecto (el nombre por defecto es el nombre de la carpeta principal) y un entorno específico (el valor por defecto es dev) para ayudarle a clasificar las pilas y clasificarlas.
    $>pulumi new python --force

This command will walk you through creating a new Pulumi project.

Enter a value or leave blank to accept the (default), and press <ENTER>.
Press ^C at any time to quit.

project name: (pulumi-oke-py)
project description: (A minimal Python Pulumi program)
Created project 'pulumi-oke-py'

stack name: (dev)
Created stack 'dev'
Enter your passphrase to protect config/secrets:
Re-enter your passphrase to confirm:

Failed to resolve python version command: fork/exec $PATH/pulumi-oke-py/venv/bin/python: no such file or directory

Installing dependencies...

Creating virtual environment...
Finished creating virtual environment
Updating pip, setuptools, and wheel in virtual environment...
Collecting pip
Using cached https://files.pythonhosted.org/packages/96/2f/caec18213f6a67852f6997fb0673ae08d2e93d1b81573edb93ba4ef06970/pip-22.1.2-py3-none-any.whl
Collecting setuptools
Using cached https://files.pythonhosted.org/packages/e9/1c/ec080fde54ab30a738c92f794eab7f5d2f354f2b619ee95b2efe353e0766/setuptools-62.3.2-py3-none-any.whl
Collecting wheel
Using cached https://files.pythonhosted.org/packages/27/d6/003e593296a85fd6ed616ed962795b2f87709c3eee2bca4f6d0fe55c6d00/wheel-0.37.1-py2.py3-none-any.whl
Installing collected packages: pip, setuptools, wheel
.....
Collecting grpcio~=1.33
Using cached grpcio-1.46.3-cp37-cp37m-macosx_10_10_x86_64.whl (4.3 MB)
Installing collected packages: six, semver, pyyaml, protobuf, dill, grpcio, pulumi
Successfully installed dill-0.3.5.1 grpcio-1.46.3 protobuf-3.20.1 pulumi-3.33.2 pyyaml-5.4.1 semver-2.13.0 six-1.16.0
Finished installing dependencies

Your new project is ready to go! ✨

To perform an initial deployment, run 'pulumi up'

    Nota: Al almacenar un archivo de estado localmente en la misma ruta que la pila, la opción -force es necesaria porque el directorio no está vacío (contiene la carpeta pulumi-statefile).

  3. Ahora ejecutará el despliegue inicial. Mantenga a mano la frase de contraseña que introdujo en el paso anterior.

       $> pulumi up
   Enter your passphrase to unlock config/secrets
      (set PULUMI_CONFIG_PASSPHRASE or PULUMI_CONFIG_PASSPHRASE_FILE to remember):
   Previewing update (dev):
      Type                 Name             Plan
   +   pulumi:pulumi:Stack  pulumi-oke-py-dev  create

   Resources:
      + 1 to create

   Do you want to perform this update? yes
   Updating (dev):
      Type                 Name             Status
   +   pulumi:pulumi:Stack  pulumi-oke-py-dev  created

   Resources:
      + 1 created

   Duration: 1s

  4. Confirme que el entorno se crea mediante los siguientes comandos.

    Nota: justo después de crear y almacenar la plantilla correctamente, Pulumi también creará un entorno (venv) virtual de Python con paquetes de sitios utilizados por el programa Python. Los entornos virtuales no están dentro del ámbito de este tutorial.

    -rw-r--r--. 1 <user> oci 45 May 23 20:07 __main__.py
-rw-r--r--. 1 <user> oci 117 May 23 20:07 Pulumi.yaml
-rw-r--r--. 1 <user> oci 21 May 23 20:07 requirements.txt
-rw-r--r--. 1 <user> oci 21 May 23 20:07 Pulumi.dev.yaml
drwxr-xr-x. 5 <user> oci 100 May 23 20:08 venv
drwxr-xr-x. 5 <user> oci 100 May 23 20:06 oci-stack-statefile

    • __main__py : punto de entrada para su aplicación Python y esto es lo que Pulumi analizará.

    • Pulumi.yaml: descriptor de pila.

    • Pulumi.dev.yaml: configuración del entorno de pila.

    • requirements.txt: archivo estándar definido para mostrar los paquetes pithon necesarios de pip.

    • venv: entorno virtual de Python.

Tarea 2: Configurar el entorno virtual de Python

Pulumi ha registrado el proveedor de OCI y está disponible a través de pip. pip es un gestor de paquetes de Python para instalar bibliotecas existentes. Vamos a instalarlo, pero solo en el entorno virtual.

  1. Active el entorno virtual de Python con el siguiente comando.

    $>  source venv/bin/activate

  2. Instale el paquete pulumi_oci con pip.

    (venv) j2joi@cloudshell:pulumi-oke-py (us-ashburn-1)$  pip install pulumi_oci

  3. Configure el proveedor de OCI para Pulumi.

    Nota: Pulumi almacena los detalles de configuración en su propio servicio de configuración. Debe configurar el proveedor de OCI para Pulumi para autenticarse en su arrendamiento. Recopile el perfil de usuario, la clave de API, el ocid de usuario, el ocid de arrendamiento, la región y almacénelo como secretos dentro de la configuración de entorno de pulumi. Tenga en cuenta que los transferirá como secretos, de modo que se cifrarán con la frase de contraseña proporcionada al crear el entorno.

    $> pulumi config set oci:tenancyOcid "ocid1.tenancy.oc1..<unique_ID>" --secret  
$> pulumi config set oci:userOcid "ocid1.user.oc1..<unique_ID>" --secret
$> pulumi config set oci:fingerprint "<key_fingerprint>" --secret
$> pulumi config set oci:region "<target region in OCI>"
$> cat "~/.oci/oci_api_key.pem" | pulumi config set oci:privateKey --secret
$> pulumi config set compartment_ocid "ocid1.compartment.oc1..aaaaaaaaqiuXXXXXXXXXX"

    Consejo:

    • Exporte PULUMI_CONFIG_PASSPHRASE con su valor de frase de contraseña. Ahorrará tiempo en lugar de proporcionarlo cada vez que se agregue un secreto.
    • Los valores de configuración de OCI se pueden leer directamente desde variables de entorno con el formato TF_VAR_${var_name}.

  4. Confirme que sus secretos están almacenados en el almacén de configuración.

    $> (venv) j2joi@cloudshell:pulumi-oke-py (us-ashburn-1)$  pulumi config

KEY VALUE
oci:fingerprint [secret]
oci:privateKey [secret]
oci:region us-ashburn-1
oci:tenancyOcid [secret]
oci:userOcid [secret]

    Nota: Pulumi utiliza dos tipos de variable principales, entrada [T] y salida[T] de tipo T. Input[T] es un envoltorio para valores raw de tipos de datos básicos de Python (cadena, booleano, representación, secuencia) y Output contiene el valor futuro una vez creado el recurso.

    Tenga esto en cuenta si está intentando manipular el valor de una salida transfiriéndolo a cualquier biblioteca estándar de Python, es decir, intentando dividir un nombre de [cadena] de salida de recurso, como name.split(), ya que terminará con error porque la variable de nombre de tipo Salida no admite la división.

  5. Cree el primer cluster de OKE. Antes de empezar a codificar, el siguiente fragmento de código requiere la creación de una red virtual en la nube existente. Las subredes de OKE deben tener 3 subredes necesarias para el punto final de Kubernetes, los nodos de trabajador y el servicio de equilibrador de carga. Para obtener más información sobre los requisitos de subred para OKE, como política o enrutamiento, consulte la documentación de OCI.

    Repasemos la definición de variable de Python de cluster de OCI:

    Type: pulumi_oci.containerengine.Cluster

Arguments:

   - compartment_id : This is the Oracle Cloud Identifier OCID linked to the target compartment.
   - kubernetes_version : Update with the Kubernetes main stream versions that are supported in OCI.
   - name: This is the Kubernetes cluster displayed name.
   - options: Network CIDRs for different services and a list of subnets used for loadbalancer services, wrapped in a ClusterOptionsKubernetesNetworkConfigArgs object.
   - endpoint_config - Define if the cluster Kubernetes endpoint will have a public IP address and which subnet it will be attached to.
   - vcn_id - Virtual cloud network the Kubernetes cluster will be attached to.

  6. Una vez que la VCN de OCI esté lista y tenga los detalles de VCN, subredes y OCID de compartimento, edite el archivo __main__.yaml con el siguiente fragmento de código. Actualice los valores con los OCID correspondientes.

     "A Python Pulumi program"
 import pulumi
 import pulumi_oci as oci

 config = pulumi.Config()

 target_compartment_ocid = "ocid1.compartment.oc1.iad.XXXXXXX"

 subnets_lb_ocid= ["ocid1.subnet.oc1.iad.aaaaaaaan6fXXXXXXXXX"]

 subnet_workernodes_ocid = "ocid1.subnet.oc1.iad.aaaaaaaakYYYYYYY"

 subnet_endpoint_ocid = "ocid1.subnet.oc1.iad.aaaaaaaaxmfZZZZZZZZZ"

 vcn_ocid="ocid1.vcn.oc1.iad.amaaaaaadoggtjaasym4AAAAAAAAAA"

 kubernetes_version="v1.23.4"

 oke_cluster_opts_args = oci.containerengine.ClusterOptionsArgs(
 kubernetes_network_config=oci.containerengine.ClusterOptionsKubernetesNetworkConfigArgs(
 pods_cidr="10.244.0.0/16",
 services_cidr="10.96.0.0/16"),
 service_lb_subnet_ids = subnets_lb_ocid
 )

 oke_cluster = oci.containerengine.Cluster("oke_cluster",
 compartment_id = target_compartment_ocid,
 kubernetes_version = kubernetes_version,
 name = "firstPulumiPy_OKE",
 options = oke_cluster_opts_args,
 endpoint_config = oci.containerengine.ClusterEndpointConfigArgs(
 is_public_ip_enabled = True,
 subnet_id = subnet_endpoint_ocid),
 vcn_id = vcn_ocid,
 )
 pulumi.export("oke_cluster_ocid", oke_cluster)

    Consejo: puede solicitar OCID de recursos del almacén de configuración de Pulumi para reutilizar el código para otros entornos en lugar de asignar valores de OCID directamente en el código de Python.

    Nota: La sangría es esencial para Python. Asegúrese de que el código sigue la sangría de Python.

  7. Revisar los cambios de infraestructura: Pulumi tiene la opción de obtener una vista previa de los recursos que va a crear/modificar la pila actual. Ejecute la opción "pulumi Preview" para validar la pila de python actual.

    (venv) j2joi@cloudshell:pulumi-oke-py (us-ashburn-1)$ pulumi preview
Previewing update (dev)

     Type                            Name               Plan       Info
 +   pulumi:pulumi:Stack             pulumi-oke-py-dev  create     1 message
 +   └─ oci:ContainerEngine:Cluster  oke_cluster        create

  8. Aplicar cambios a la infraestructura: si no se muestra ningún mensaje de error, puede crear un cluster de OKE. Ejecute "pulumi up" para disparar la pila para aplicar los cambios.

    (venv) j2joi@cloudshell:pulumi-oke-py (us-ashburn-1)$ pulumi up
Updating (dev)

     Type                            Name               Status      Info
 +   pulumi:pulumi:Stack             pulumi-oke-py-dev  created     12 messages
 +   └─ oci:ContainerEngine:Cluster  oke_cluster        created

  9. Agregue un recurso de pool de nodos de OKE: Pulumi Stack creó el primer cluster de OKE "oke_cluster". Ahora, permite agregar nodos de trabajador asignados a una variable de pool de nodos en el mismo archivo main.py. Los cambios se agregarán de forma incremental a su conjunto de recursos en OCI porque Pulumi realiza un seguimiento de los recursos creados y comparará cualquier diferencia entre el recurso dentro del proveedor en la nube y el estado almacenado en el backend seleccionado para validar si se necesitan actualizaciones para los recursos nuevos o existentes.

    Worker node Compute Instance details
number_worker_nodes= 3
default_node_memory_size=16
default_node_num_ocpus =1

# Get the Availability Domain names for this region
ad_list=oci.identity.get_availability_domains(target_compartment_ocid)
ad=ad_list.availability_domains

# Get the list of supported images based on the compartment and filter it by most recent image
list_of_supported_image =oci.core.get_images(compartment_id=target_compartment_ocid,
                                      operating_system="Oracle Linux",
                                      operating_system_version= "7.9",
                                      shape= "VM.Standard.E3.Flex",
                                      sort_by="TIMECREATED",
                                      sort_order="DESC"
                                      )
#Obtain the first image ocid from  list_of_supported_image var
os_image_ocid= list_of_supported_image.images[0].id

# Pin for this example all worker nodes to a first Availability Domain
place_nodes_subnet=[oci.containerengine.NodePoolNodeConfigDetailsPlacementConfigArgs(
                availability_domain=ad[0].name,
                subnet_id= subnet_workernodes_ocid
            ),]

#Declare all Pool properties
node_pool_args = oci.containerengine.NodePoolArgs(cluster_id=oke_cluster.id,
                                                      compartment_id= target_compartment_ocid,
                                                      kubernetes_version=kubernetes_version,
                                                      node_shape= "VM.Standard.E3.Flex",
                                                      name="E3Flex",
                                                      node_config_details=oci.containerengine.NodePoolNodeConfigDetailsArgs(
                                                          placement_configs= place_nodes_subnet ,
                                                          size= number_worker_nodes
                                                      ),
                                                      node_shape_config=oci.containerengine.NodePoolNodeShapeConfigArgs(
                                                          memory_in_gbs= default_node_memory_size,
                                                          ocpus= default_node_num_ocpus,
                                                      ),
                                                      node_source_details=oci.containerengine.NodePoolNodeSourceDetailsArgs(
                                                          image_id= os_image_ocid,
                                                          source_type="IMAGE",
                                                          boot_volume_size_in_gbs=60,
                                                      ),
                                                      )
#Assign node pool properties as args to node_pool
node_pool = oci.containerengine.NodePool("nodepool", args=node_pool_args)

pulumi.export("oke_cluster_ocid", oke_cluster)
pulumi.export("oke_node_pool", node_pool)

  10. Vuelva a actualizar la infraestructura ejecutando el comando "pulumi up".

    $> pulumi up

Información adicional

Pulumi Marketplace ya tiene otros proveedores existentes que puede utilizar, como Kubernetes, Helm, etc. Una ventaja de crear recursos en Oracle Cloud, como Kubernetes, es que es compatible con la mayoría de los estándares de Kubernetes y la integración es sencilla. En el siguiente ejemplo se muestra cómo crear su propio proveedor de Kubernetes mediante el proveedor de Pulumi y cómo desplegar aplicaciones en su código de Python.

import pulumi_kubernetes

kubeconfig = oci.containerengine.get_cluster_kube_config_output(cluster_id=oke_cluster.id).apply(
   lambda kube_config: kube_config.content)

k8sProvider = pulumi_kubernetes.Provider("okeK8s",
                                        kubeconfig=kubeconfig
                                        )


pulumi.export("kubeconfig", kubeconfig)

Tarea 3: Eliminar recursos

Ha completado su primera pila de Python con el proveedor de OCI para Pulumi. Para suprimir todos los recursos, ejecute el comando pulumi destroy.

$> pulumi destroy

pulumi destroy
Previewing destroy (dev):
     Type                            Name             Plan
 -   pulumi:pulumi:Stack             local-state-dev  delete
 -   └─ oci:ContainerEngine:Cluster  oke_cluster      delete

Confirmaciones

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 Oracle Learning Explorer.

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