Imágenes de máquinas personalizadas de Linux (heredado)

Este procedimiento le guiará por el proceso de creación de una imagen de máquina personalizada de Linux para usarla al crear clústeres basados en planes (heredados) en AWS, Azure o vSphere. Se divide en las siguientes secciones. Para obtener más información sobre los tipos de clústeres en Tanzu Kubernetes Grid, consulte Tipos de clústeres de carga de trabajo.

Requisitos previos de imagen de Linux muestra lo que necesita para compilar y utilizar correctamente una imagen de Linux personalizada.
Compilar una imagen de Linux muestra cómo utilizar Kubernetes Image Builder y Docker para personalizar y compilar una imagen.
Crear un TKr para la imagen de Linux muestra cómo convertir la imagen de Linux en una versión de Tanzu Kubernetes (TKr), lo que convertiría la imagen en la predeterminada para futuras versiones de Kubernetes y le ofrecería más opciones para usarla y administrarla.
Usar una imagen de Linux para un clúster de administración muestra cómo implementar un clúster de administración que utiliza la imagen personalizada como plantilla.
Usar una imagen de Linux para un clúster de carga de trabajo muestra cómo implementar un clúster de carga de trabajo que utiliza la imagen personalizada como plantilla.

Requisitos previos de imagen de Linux

Para crear una imagen de máquina personalizada de Linux, necesita:

Una cuenta en la infraestructura de destino, AWS, Azure o vSphere.
Una estación de trabajo macOS o Linux con lo siguiente instalado:
- Escritorio de Docker
- Para AWS: La interfaz de línea de comandos aws (CLI)
- Para Azure: La CLI az
- Para vSphere: Para crear una imagen RHEL 8, necesita una estación de trabajo Linux, no macOS.

Compilar una imagen de Linux

En AWS y Azure, inicie sesión en la CLI de infraestructura. Autentique y especifique su región, si se le solicita:
- AWS: Ejecute aws configure.
- Azure: Ejecute az login.
En Azure, cree un archivo JSON de configuración azure-sig.json y rellene la información específica de Azure. Se puede encontrar un ejemplo de dicho archivo aquí.

En vSphere, cree un archivo JSON de credenciales y rellene sus valores:

{
"cluster": "",
"convert_to_template": "false",
"create_snapshot": "true",
"datacenter": "",
"datastore": "",
"folder": "",
"insecure_connection": "false",
"linked_clone": "true",
"network": "",
"password": "",
"resource_pool": "",
"template": "",
"username": "",
"vcenter_server": ""
}

Determine la versión de configuración de Image Builder a partir de la que desea compilar.
- Busque el VMware {code} Sample Exchange para TKG Image Builder para ver una lista de las versiones disponibles.
- Cada versión de Image Builder corresponde a sus versiones compatibles de Kubernetes y Tanzu Kubernetes Grid. Por ejemplo,TKG-Image-Builder-for-Kubernetes-v1.24.10-on-TKG-v2.1.1-master.zip crea una imagen de Kubernetes v1.24.10 para Tanzu Kubernetes Grid v2.1.1.
- Si necesita crear un clúster de administración, que debe hacer cuando instale Tanzu Kubernetes Grid por primera vez, elija la versión de Kubernetes predeterminada de la versión de Tanzu Kubernetes Grid. Por ejemplo, en Tanzu Kubernetes Grid v2.1.1, la versión predeterminada de Kubernetes es la 1.24.10. Para los clústeres de carga de trabajo, también puede crear una imagen de Kubernetes v1.23.16 o v1.22.17, además de la v1.24.10.
Los siguientes pasos explican cómo crear una imagen de Kubernetes v1.24.10 para Tanzu Kubernetes Grid v2.1.1.
Descargue el archivo zip del código de configuración y desempaquete su contenido.
cd en el directorio TKG-Image-Builder-, de modo que el archivo tkg.json se encuentre en el directorio actual.
Asegúrese de que la estación de trabajo pueda acceder al registro de imágenes VMware projects.registry.vmware.com.

Descargue y ejecute el contenedor de artefactos deseado desde projects.registry.vmware.com.

docker pull projects.registry.vmware.com/tkg/linux-resource-bundle:v1.24.10_vmware.1-tkg.2

docker run -d -p 3000:3000 projects.registry.vmware.com/tkg/linux-resource-bundle:v1.24.10_vmware.1-tkg.2

Edite tkg.json para rellenar <IP> y <PORT>, donde:
- IP corresponde a la dirección IP de la máquina que ejecuta el contenedor de Docker.
- PORT asocia un puerto no utilizado en el host Docker con el puerto 3000 en el contenedor, por ejemplo, 3001:3000. El contenedor expone los artefactos a través del puerto 3000.
Si crea un archivo OVA en Photon-3, edite "extra_rpms" en tkg.json para reflejar los paquetes personalizados adicionales compatibles:
```
"extra_rpms": "sysstat nfs-utils ethtool apparmor-parser"
```
Para crear una imagen compatible con FIPS, elimine la siguiente línea en tkg.json:
```
"ansible_user_vars": "install_fips=no"
```
Restringido por Internet: Para crear imágenes para un entorno restringido por Internet que acceda a Internet a través de un servidor proxy HTTP, agregue lo siguiente al archivo tkg.json:
```
{
  "http_proxy": "http://proxy.acme.com:80",
  "https_proxy": "http://proxy.acme.com:80",
  "no_proxy": "localhost, 127.0.0.1, acme.com, 10.0.0.0/8"
}
```
Clústeres habilitados para GPU: Para crear una imagen para un clúster habilitado para GPU para vSphere, cree un archivo denominado customizations.json y agregue lo siguiente:
```
{
"vmx_version": "17"
}
```
Guarde el archivo customizations.json en el mismo directorio que tkg.json que editó en un paso anterior.
Recopile las siguientes cadenas de parámetros para conectarse al comando en el siguiente paso. Muchos de estos especifican los parámetros docker run -v que copian los directorios de trabajo actuales en el directorio /home/imagebuilder del contenedor utilizado para compilar la imagen.
- AUTHENTICATION: Copia el directorio de la CLI local:
  - AWS: Utilice ~/.aws:/home/imagebuilder/.aws
  - Azure: Utilice ~/.azure:/home/imagebuilder/.azure
  - vSphere: /PATH/TO/CREDENTIALS.json:/home/imagebuilder/vsphere.json
- SOURCES: Copia el archivo tkg.json del repositorio, que enumera los orígenes de descarga del sistema operativo con versiones, Kubernetes y la interfaz de red de contenedor (Container Network Interface, CNI). Imágenes:
  - Utilice /PATH/TO/tkg.json:/home/imagebuilder/tkg.json
- ROLES: Copia el directorio tkg del repositorio, que contiene las funciones de Ansible requeridas por Image Builder.
  - Utilice /PATH/TO/tkg:/home/imagebuilder/tkg
  - Para agregar funciones personalizadas de Ansible, edite el archivo tkg.json para volver a formatear la configuración de custom_role_names con comillas de escape (\") para convertirla en una lista con varias funciones. Por ejemplo:
    "custom_role_names": "\"/home/imagebuilder/tkg /home/imagebuilder/mycustomrole\"",
- TESTS: Copia un directorio de prueba goss diseñado para la infraestructura de destino de la imagen, el sistema operativo y la versión de Kubernetes:
  - Utilice el nombre de archivo de un archivo en el directorio goss del repositorio (por ejemplo, amazon-ubuntu-1.24.10+vmware.1-goss-spec.yaml.
- CUSTOMIZATIONS: Copia un archivo de personalización en formato JSON. Consulte Personalización en la documentación de Image Builder. Antes de realizar modificaciones, consulte con VMware Customer Reliability Engineering (CRE) para conocer las prácticas recomendadas y las recomendaciones.
- PACKER_VAR_FILES: Una lista delimitada por espacios de los archivos JSON anteriores que contiene variables para Packer.
- (Azure) AZURE-CREDS: Ruta de acceso a un archivo de credenciales de Azure, como se describe en la documentación de Image Builder.
- COMMAND: Use un comando como uno de los siguientes, en función del sistema operativo de imagen personalizado. Para las imágenes de Azure y vSphere, los comandos comienzan con build-node-ova- y build-azure-sig-:
  - build-ami-ubuntu-2004: Ubuntu v20.04
  - build-ami-ubuntu-1804: Ubuntu v18.04
  - build-ami-amazon-2: Amazon Linux 2
  - build-node-ova-vsphere-ubuntu-2004: Clústeres habilitados para GPU

Con las cadenas anteriores, ejecute Image Builder en un contenedor docker extraído del registro VMware projects.registry.vmware.com:

docker run -it --rm \
    -v AUTHENTICATION \
    -v SOURCES \
    -v ROLES \
    -v /PATH/TO/goss/TESTS.yaml:/home/imagebuilder/goss/goss.yaml \
    -v /PATH/TO/CUSTOMIZATIONS.json:/home/imagebuilder/CUSTOMIZATIONS.json \
    --env PACKER_VAR_FILES="tkg.json CUSTOMIZATIONS.json" \
    --env-file AZURE-CREDS \
    --env IB_OVFTOOL=1 \
    projects.registry.vmware.com/tkg/image-builder:v0.1.13_vmware.2 \
    COMMAND

Nota
Omita env-file si no crea una imagen para Azure. Este comando puede tardar varios minutos en completarse.

Por ejemplo, para crear una imagen personalizada con Ubuntu v20.04 y Kubernetes v1.24.10 para ejecutarse en AWS, ejecutándose desde el directorio que contiene tkg.json

docker run -it --rm \
    -v ~/.aws:/home/imagebuilder/.aws \
    -v $(pwd)/tkg.json:/home/imagebuilder/tkg.json \
    -v $(pwd)/tkg:/home/imagebuilder/tkg \
    -v $(pwd)/goss/amazon-ubuntu-1.24.10+vmware.1-goss-spec.yaml:/home/imagebuilder/goss/goss.yaml \
    -v /PATH/TO/CUSTOMIZATIONS.json /home/imagebuilder/aws.json \
    --env PACKER_VAR_FILES="tkg.json aws.json" \
    --env IB_OVFTOOL=1 \
    projects.registry.vmware.com/tkg/image-builder:v0.1.13_vmware.2 \
    build-ami-ubuntu-2004

Para vSphere, debe utilizar la imagen de contenedor personalizada creada anteriormente. También debe establecer una cadena de versión que coincida con lo que ha pasado en el TKr personalizado en los pasos posteriores. Si bien VMware archivos OVA publicados tendrán una cadena de versión como v1.24.10+vmware.1-tkg.1, se recomienda que la -tkg.1 se reemplace por una cadena significativa para su organización. Para establecer esta cadena de versión, defínela en un archivo metadata.json como el siguiente:

{
  "VERSION": "v1.24.10+vmware.1-myorg.0"
}

Al crear archivos OVA, el archivo .ova se guarda en el sistema de archivos local de la estación de trabajo. La carpeta en la que desee que se guarden los archivos OVA debe montarse en /home/imagebuilder/output dentro del contenedor. A continuación, cree el archivo OVA mediante la imagen del contenedor:

docker run -it --rm \
  -v /PATH/TO/CREDENTIALS.json:/home/imagebuilder/vsphere.json \
  -v $(pwd)/tkg.json:/home/imagebuilder/tkg.json \
  -v $(pwd)/tkg:/home/imagebuilder/tkg \
  -v $(pwd)/goss/vsphere-ubuntu-1.24.10+vmware.1-goss-spec.yaml:/home/imagebuilder/goss/goss.yaml \
  -v $(pwd)/metadata.json:/home/imagebuilder/metadata.json \
  -v /PATH/TO/OVA/DIR:/home/imagebuilder/output \
  --env PACKER_VAR_FILES="tkg.json vsphere.json" \
  --env OVF_CUSTOM_PROPERTIES=/home/imagebuilder/metadata.json \
  --env IB_OVFTOOL=1 \
  projects.registry.vmware.com/tkg/image-builder:v0.1.13_vmware.2 \
  build-node-ova-vsphere-ubuntu-2004

Para los clústeres habilitados para GPU, es necesario incluir el archivo customizations.json creado en los pasos anteriores al ejecutar el comando para crear el archivo OVA.

docker run -it --rm \
  -v /PATH/TO/CREDENTIALS.json:/home/imagebuilder/vsphere.json \
  -v $(pwd)/tkg.json:/home/imagebuilder/tkg.json \
  -v $(pwd)/tkg:/home/imagebuilder/tkg \
  -v $(pwd)/goss/vsphere-ubuntu-1.24.10+vmware.1-goss-spec.yaml:/home/imagebuilder/goss/goss.yaml \
  -v $(pwd)/metadata.json:/home/imagebuilder/metadata.json \
  -v $(pwd)/customizations.json:/home/imagebuilder/customizations.json \
  -v /PATH/TO/OVA/DIR:/home/imagebuilder/output \
  --env PACKER_VAR_FILES="tkg.json vsphere.json customizations.json" \
  --env OVF_CUSTOM_PROPERTIES=/home/imagebuilder/metadata.json \
  --env IB_OVFTOOL=1 \
  projects.registry.vmware.com/tkg/image-builder:v0.1.13_vmware.2 \
  build-node-ova-vsphere-ubuntu-2004

RHEL: Para crear un archivo OVA de RHEL, debe usar una máquina Linux, no macOS, ya que Docker en macOS no admite la opción --network host.
También debe registrar el sistema operativo como con licencia con Red Hat y registrarse para las actualizaciones agregando lo siguiente al comando docker run anterior:

  -v $(pwd)/isos/rhel-8.4-x86_64-dvd.iso:/rhel-8.4-x86_64-dvd.iso \
  --network host \
  --env RHSM_USER=USER --env RHSM_PASS=PASS

Donde:

RHSM_USER y RHSM_PASS son el nombre de usuario y la contraseña para su cuenta de Red Hat Subscription Manager.
Asigne la ruta ISO de RHEL local en $(pwd)/isos/rhel-8.4-x86-64-dvd.iso en el ejemplo anterior, como un volumen adicional.

Crear un TKr para la imagen de Linux

Para que la imagen de Linux sea la predeterminada para futuras versiones de Kubernetes, cree un TKr basado en ella. De lo contrario, vaya a Usar una imagen de Linux para un clúster de carga de trabajo.

El siguiente diagrama proporciona una descripción general de alto nivel de cómo crear un TKr para una imagen de Linux personalizada en vSphere.

Crear un TKr

Para crear un TKr:

En el directorio ~/.config/tanzu/tkg/bom/, abra TKr BoM correspondiente a la versión de Kubernetes de la imagen personalizada. Por ejemplo, con un nombre de archivo como tkr-bom-v1.24.10+vmware.1-tkg.1.yaml para Kubernetes v1.24.10.

Si el directorio no tiene el archivo TKr BoM que necesita, puede introducirlo implementando un clúster con la versión de Kubernetes deseada, como se describe en Implementar un clúster con una versión de Kubernetes no predeterminada.
1. En el archivo de BoM, busque los bloques de definición de imagen para la infraestructura: ova para vSphere, ami para AWS y azure para Azure. Cada bloque de definiciones de imágenes contiene osinfo.name, osinfo.version y osinfo.arch, donde:
  - osinfo.name es el nombre del sistema operativo. Por ejemplo, ubuntu. Para ver la lista de sistemas operativos compatibles, consulte Sistemas operativos principales.
  - osinfo.version es la versión del sistema operativo. Por ejemplo, 20.04. Para ver la lista de versiones compatibles, consulte Sistemas operativos principales.
  - osinfo.arch es el arco del SO. El valor compatible es amd64.
2. Para agregar una referencia a la nueva imagen de SO, agregue un bloque de definición de imagen en ova, ami o azure, según la infraestructura de destino. El bloque de definición de imagen debe contener osinfo.name, osinfo.version y osinfo.arch, como se describe anteriormente. Además, al agregar un bloque de definición de imagen en:
  - vSphere:
    - name: es un nombre único para su OVA que incluye la versión del sistema operativo, por ejemplo, my-ova-ubuntu-2004.
    - version: use la VERSION única asignada en metadata.json cuando creó el archivo OVA, por ejemplo, v1.24.10+vmware.1-myorg.0.
    Nota
    La version debe coincidir exactamente con la misma VERSION en metadata.json.
  - AWS: Para cada región en la que tenga pensado utilizar la imagen personalizada, siga el formato de valor id existente, pero utilice una cadena hexadecimal única al final, por ejemplo, ami-693a5e2348b25e428.
  Si el archivo de BoM define imágenes en regiones, el bloque de definición de imágenes personalizadas debe aparecer en primer lugar en su región. Dentro de cada región, el proceso de creación del clúster selecciona la primera imagen adecuada que aparece en la lista.
3. En el valor release.version, agregue un sufijo para establecer una versión personalizada. No personalice la versión agregando un prefijo. Por ejemplo, cambie v1.24.10+vmware.1-tkg.1 a v1.24.10+vmware.1-tkg.1-mycustomtkr.
4. Guarde el archivo de BoM con el mismo sufijo personalizado que especificó para release.version en el paso anterior.
  
  Si el nombre de archivo incluye un carácter más (+), reemplace el + por un guion triple (---).
  
  Por ejemplo, guarde el archivo BoM como tkr-bom-v1.24.10---vmware.1-tkg.1-mycustomtkr.yaml.
base64 codificar el contenido del archivo en una cadena binaria, por ejemplo:
```
cat tkr-bom-v1.24.10---vmware.1-tkg.1-mycustomtkr.yaml | base64 -w 0
```
Cree un archivo YAML de ConfigMap, por ejemplo denominado configmap-v1.24.10---vmware.1-tkg.1-mycustomtkr.yaml, con valores como se muestra:
```
apiVersion: v1
kind: ConfigMap
metadata:
 name: CUSTOM-TKG-BOM
 labels:
   tanzuKubernetesRelease: CUSTOM-TKR
binaryData:
 bomContent: "BOM-BINARY-CONTENT"
```
Donde:
- CUSTOM-TKG-BOM es el nombre de ConfigMap, que debe incluir el valor de TKr release.version que especificó en el archivo DE MATERIALES y reemplazar cualquier símbolo + por un guion triple (—). Por ejemplo, establezca v1.24.10---vmware.1-tkg.1-mycustomtkr.
- CUSTOM-TKR es un nombre para el TKr, que debe coincidir con el valor que especifique para CUSTOM-TKG-BOM. Por ejemplo, v1.24.10---vmware.1-tkg.1-mycustomtkr.
- BOM-BINARY-CONTENT es el contenido codificado en base64 del archivo de BoM personalizado que generó en el paso anterior.
Por ejemplo:
```
apiVersion: v1
kind: ConfigMap
metadata:
 name: v1.24.10---vmware.1-tkg.1-mycustomtkr
 labels:
   tanzuKubernetesRelease: v1.24.10---vmware.1-tkg.1-mycustomtkr
binaryData:
 bomContent: "YXBpVmVyc2lvbjogcnVuLnRhbnp1...."
```
Guarde el archivo ConfigMap, establezca el contexto kubectl en un clúster de administración al que desee agregar TKr y aplique el archivo al clúster, por ejemplo:
```
kubectl -n tkr-system apply -f configmap-v1.24.10---vmware.1-tkg.1-mycustomtkr.yaml
```
El controlador de TKr concilia el nuevo objeto ConfigMap creando un TanzuKubernetesRelease. El período de conciliación predeterminado es de 600 segundos. Para evitar este retraso, elimine el pod de TKr Controller, lo que hace que el pod se restaure y se concilia inmediatamente:
1. Lista de pods en el espacio de nombres tkr-system:
```
kubectl get pod -n tkr-system
```
2. Recupere el nombre del pod de TKr Controller, que tiene el aspecto tkr-controller-manager-f7bbb4bd4-d5lfd
3. Elimine el pod:
```
kubectl delete pod -n tkr-system TKG-CONTROLLER
```
  Donde TKG-CONTROLLER es el nombre del pod de TKr Controller.
Para comprobar que se agregó el TKr personalizado, ejecute tanzu kubernetes-release get o kubectl get tkr o y busque el valor CUSTOM-TKR establecido anteriormente en el resultado.

Una vez que el TKr personalizado aparezca en la lista de CLI de kubectl y tanzu, puede utilizarlo para crear clústeres de administración o de carga de trabajo, como se describe a continuación.

Usar una imagen de Linux para un clúster de administración

Para crear un clúster de administración que utilice la imagen personalizada como sistema operativo base para sus nodos:

Cargue la imagen en el proveedor de nube.
Al ejecutar la interfaz del instalador, seleccione la imagen personalizada en el panel de imagen de sistema operativo, tal como se describe en Seleccionar imagen del sistema operativo base.

Para obtener más información, consulte Cómo se generan las opciones de imagen del sistema operativo base.

Usar una imagen de Linux para un clúster de carga de trabajo

El procedimiento para crear un clúster de carga de trabajo a partir de la imagen de Linux varía en función de si creó un TKr en Crear un TKr para la imagen de Linux anterior.

Si creó un TKr, pase el nombre de TKr como aparece en tanzu kubernetes-release get a la opción --tkr de tanzu cluster create.
Si no creó un TKr, siga estos pasos:
1. Copie el archivo de configuración del clúster de administración y guárdelo con un nombre nuevo siguiendo el procedimiento descrito en Especificaciones de objetos y archivos de configuración.
2. En el nuevo archivo de configuración, agregue o modifique lo siguiente:
```
VSPHERE_TEMPLATE: LINUX-IMAGE
```
  Donde LINUX-IMAGE es el nombre de la imagen de Linux que creó en Compilar una imagen de Linux.
  
  Elimine CLUSTER_NAME y su configuración, si existe.
3. Implemente un clúster de carga de trabajo como se describe en Crear clústeres de carga de trabajo.