30 GPUs de NVIDIA en SUSE Linux Micro #
30.1 Introducción #
Esta guía demuestra cómo implementar soporte para GPU de NVIDIA a nivel de host a través de los controladores de código abierto precompilados en SUSE Linux Micro 6.2. Estos son controladores que están integrados en el sistema operativo en lugar de ser cargados dinámicamente por el operador de GPU de NVIDIA. Esta configuración es muy deseable para los clientes que desean preintegrar todos los artefactos necesarios para la ampliación en la imagen, y donde la selección dinámica de la versión del controlador, es decir, que el usuario seleccione la versión del controlador a través de Kubernetes, no es un requisito. Esta guía explica inicialmente cómo desplegar los componentes adicionales en un sistema que ya ha sido predesplegado, pero continúa con una sección que describe cómo integrar esta configuración en la ampliación inicial a través de Edge Image Builder. Si no desea repasar los conceptos básicos y configurar las cosas manualmente, pase directamente a esa sección.
Es importante señalar que el soporte para estos controladores lo proporcionan tanto SUSE como NVIDIA en estrecha colaboración, donde el controlador es compilado y distribuido por SUSE como parte de los repositorios de paquetes. Sin embargo, si tiene alguna duda o pregunta sobre la combinación en la que utiliza los controladores, solicite más ayuda a sus gestores de cuenta de SUSE o NVIDIA. Si planea utilizar NVIDIA AI Enterprise (NVAIE), asegúrese de utilizar una GPU certificada para NVAIE, lo cual podría requerir el uso de controladores propietarios de NVIDIA. Si no está seguro, hable con su representante de NVIDIA.
Más información sobre la integración del operador de GPU de NVIDIA no está cubierta en esta guía. Aunque la integración del operador de GPU de NVIDIA para Kubernetes no se trata aquí, puede seguir la mayoría de los pasos de esta guía para configurar el sistema operativo subyacente y simplemente habilitar el operador de GPU para utilizar los controladores preinstalados a través del indicador driver.enabled=false en el gráfico de Helm del operador de GPU de NVIDIA, donde simplemente detectará los controladores instalados en el host. Puede encontrar instrucciones más completas de NVIDIA aquí.
30.2 Requisitos previos #
Si está siguiendo esta guía, se asume que ya dispone de lo siguiente:
Al menos un host con SUSE Linux Micro 6.2 instalado; puede ser físico o virtual.
Sus hosts están asociados a una suscripción, ya que es necesario para acceder a los paquetes; hay una evaluación disponible aquí.
Una GPU NVIDIA compatible instalada (o totalmente transferida a la máquina virtual en la que se ejecuta SUSE Linux Micro).
Acceso a la raíz: estas instrucciones asumen que es la raíz y no que está escalando sus privilegios mediante
sudo.
30.3 Instalación manual #
En esta sección, va a instalar los controladores de NVIDIA directamente en el sistema operativo SUSE Linux Micro, ya que el controlador abierto de NVIDIA forma parte ahora de los repositorios de paquetes principales de SUSE Linux Micro, lo que lo hace tan fácil como instalar los paquetes RPM necesarios. No es necesario compilar ni descargar paquetes ejecutables. A continuación, veremos cómo implementar la generación "G06" de controlador, que es compatible con las GPUs más recientes (consulte aquí para obtener más información), así que seleccione una generación de controlador adecuada para la GPU NVIDIA presente en su sistema. Para las GPU modernas, el controlador \"G06\" es la opción más común.
Antes de empezar, es importante reconocer que, además del controlador abierto de NVIDIA que SUSE distribuye como parte de SUSE Linux Micro, es posible que también necesite componentes adicionales de NVIDIA para su configuración. Estos podrían incluir bibliotecas OpenGL, kits de herramientas CUDA, utilidades de línea de comandos como nvidia-smi y componentes de integración de contenedores como nvidia-container-toolkit. Muchos de estos componentes no son distribuidos por SUSE, ya que son software propietario de NVIDIA, o no tiene sentido que los distribuyamos nosotros en lugar de NVIDIA. Por lo tanto, como parte de las instrucciones, vamos a configurar repositorios adicionales que nos den acceso a dichos componentes y veremos ciertos ejemplos de cómo utilizar estas herramientas, lo que dará como resultado un sistema totalmente funcional. Es importante distinguir entre los repositorios de SUSE y los de NVIDIA, ya que en ocasiones puede haber una discrepancia entre las versiones de los paquetes que NVIDIA pone a disposición y las que ha compilado SUSE. Esto suele ocurrir cuando SUSE pone a disposición una nueva versión del controlador abierto y pasan un par de días hasta que los paquetes equivalentes están disponibles en los repositorios de NVIDIA para que coincidan.
Le recomendamos que se asegure de que la versión del controlador que está seleccionando es compatible con su GPU y cumple con cualquier requisito de CUDA que pueda tener comprobando:
La versión del controlador que planea implementar tiene una versión coincidente en el repositorio de NVIDIA y asegurarse de que dispone de versiones de paquete equivalentes para los componentes de soporte
Para encontrar las versiones del controlador abierto de NVIDIA, ejecute zypper se -s nvidia-open-driver en la máquina de destino o busque \"nvidia-open-driver\" en el Centro de servicios al cliente de SUSE en SUSE Linux Micro 6.2 para AMD64/Intel 64.
Cuando haya confirmado que existe una versión equivalente en los repositorios de NVIDIA, estará listo para instalar los paquetes en el sistema operativo anfitrión. Para ello, necesitamos abrir una sesión transactional-update, que crea una nueva instantánea de lectura/escritura del sistema operativo subyacente para que podamos realizar cambios en la plataforma inmutable (para obtener más instrucciones sobre transactional-update, consulte aquí):
transactional-update shellCuando se encuentre en su shell transactional-update, añada un repositorio de paquetes adicional de NVIDIA. Esto permite incorporar utilidades adicionales, por ejemplo, nvidia-smi:
zypper ar https://download.nvidia.com/suse/sle15sp6/ nvidia-suse-main
zypper --gpg-auto-import-keys refreshA continuación, puede instalar el controlador y nvidia-compute-utils para utilidades adicionales. Si no necesitas las utilidades, puedes omitirlas, pero para fines de prueba, vale la pena instalarlas en esta etapa:
zypper install -y --auto-agree-with-licenses nvidia-open-driver-G06-signed-kmp nvidia-compute-utils-G06Si la instalación falla, esto podría indicar una incompatibilidad de dependencias entre la versión del controlador seleccionada y la que NVIDIA ofrece en sus repositorios. Consulte la sección anterior para verificar que sus versiones coinciden. Intenta instalar una versión de controlador diferente. Por ejemplo, si los repositorios de NVIDIA tienen una versión anterior, puede intentar especificar nvidia-open-driver-G06-signed-kmp=550.54.14 en su comando de instalación para indicar una versión que coincida.
A continuación, si no está utilizando una GPU compatible (recuerde que puede encontrar la lista aquí), puede comprobar si el controlador funciona habilitando la compatibilidad a nivel de módulo, pero los resultados pueden variar; omita este paso si está utilizando una GPU compatible:
sed -i '/NVreg_OpenRmEnableUnsupportedGpus/s/^#//g' /etc/modprobe.d/50-nvidia-default.confAhora que ha instalado estos paquetes, es el momento de salir de la sesión transactional-update:
exitAsegúrate de haber salido de la sesión transactional-update antes de continuar.
Ahora que ha instalado los controladores, es el momento de reiniciar. Como SUSE Linux Micro es un sistema operativo inmutable, necesita reiniciarse en la nueva instantánea que creó en un paso anterior. Los controladores solo se instalan en esta nueva instantánea, por lo que no es posible cargarlos sin reiniciar en esta nueva instantánea, lo cual ocurre automáticamente. Emite el comando de reinicio cuando estés listo:
rebootUna vez que el sistema se haya reiniciado correctamente, vuelva a iniciar sesión y utilice la herramienta nvidia-smi para verificar que el controlador se ha cargado correctamente y que puede acceder a sus GPUs y enumerarlas:
nvidia-smiLa salida de este comando debería mostrar algo similar a lo siguiente, teniendo en cuenta que en el ejemplo de abajo hay dos GPUs:
+---------------------------------------------------------------------------------------+
| NVIDIA-SMI 545.29.06 Driver Version: 545.29.06 CUDA Version: 12.3 |
|-----------------------------------------+----------------------+----------------------+
| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |
| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |
| | | MIG M. |
|=========================================+======================+======================|
| 0 NVIDIA A100-PCIE-40GB Off | 00000000:17:00.0 Off | 0 |
| N/A 29C P0 35W / 250W | 4MiB / 40960MiB | 0% Default |
| | | Disabled |
+-----------------------------------------+----------------------+----------------------+
| 1 NVIDIA A100-PCIE-40GB Off | 00000000:CA:00.0 Off | 0 |
| N/A 30C P0 33W / 250W | 4MiB / 40960MiB | 0% Default |
| | | Disabled |
+-----------------------------------------+----------------------+----------------------+
+---------------------------------------------------------------------------------------+
| Processes: |
| GPU GI CI PID Type Process name GPU Memory |
| ID ID Usage |
|=======================================================================================|
| No running processes found |
+---------------------------------------------------------------------------------------+Esto concluye el proceso de instalación y verificación de los controladores de NVIDIA en su sistema SUSE Linux Micro.
30.4 Validación adicional de la instalación manual #
En esta etapa, todo lo que hemos podido verificar es que, a nivel de host, se puede acceder al dispositivo NVIDIA y que los controladores se están cargando correctamente. Sin embargo, si queremos estar seguros de que funciona, una prueba sencilla sería validar que la GPU puede recibir instrucciones de una aplicación en espacio de usuario, idealmente a través de un contenedor y mediante la biblioteca CUDA, ya que eso es lo que normalmente utilizaría una carga de trabajo real. Para ello, podemos realizar una modificación adicional en el sistema operativo anfitrión instalando el nvidia-container-toolkit (NVIDIA Container Toolkit). Primero, abre otro shell transactional-update, teniendo en cuenta que podrías haber hecho esto en una sola transacción en el paso anterior, y verás cómo hacerlo de forma totalmente automatizada en una sección posterior:
transactional-update shellA continuación, instale el paquete nvidia-container-toolkit del repositorio de NVIDIA Container Toolkit:
El
nvidia-container-toolkit.repoa continuación contiene un repositorio estable (nvidia-container-toolkit) y uno experimental (nvidia-container-toolkit-experimental). El repositorio estable se recomienda para uso en producción. El repositorio experimental está deshabilitado por defecto.
zypper ar https://nvidia.github.io/libnvidia-container/stable/rpm/nvidia-container-toolkit.repo
zypper --gpg-auto-import-keys install -y nvidia-container-toolkitCuando estéis listos, podéis salir del shell transactional-update:
exit…y reiniciad la máquina en la nueva instantánea:
rebootComo antes, debéis aseguraros de haber salido del transactional-shell y reiniciado la máquina para que los cambios surtan efecto.
Con la máquina reiniciada, podéis verificar que el sistema puede enumerar correctamente los dispositivos utilizando el NVIDIA Container Toolkit. La salida debería ser detallada, con mensajes INFO y WARN, pero sin mensajes ERROR:
nvidia-ctk cdi generate --output=/etc/cdi/nvidia.yamlEsto garantiza que cualquier contenedor iniciado en la máquina pueda emplear los dispositivos GPU de NVIDIA que se hayan descubierto. Cuando estéis listos, podéis ejecutar un contenedor basado en podman. Hacer esto mediante podman nos proporciona una buena forma de validar el acceso al dispositivo NVIDIA desde dentro de un contenedor, lo que debería dar confianza para hacer lo mismo con Kubernetes en una etapa posterior. Dad a podman acceso a los dispositivos NVIDIA etiquetados de los que se ocupó el comando anterior, basándoos en SLE BCI, y simplemente ejecutad el comando Bash:
podman run --rm --device nvidia.com/gpu=all --security-opt=label=disable -it registry.suse.com/bci/bci-base:latest bashAhora ejecutaréis comandos desde dentro de un contenedor podman temporal. No tiene acceso a vuestro sistema subyacente y es efímero, por lo que cualquier cosa que hagamos aquí no persistirá, y no deberíais poder romper nada en el host subyacente. Como ahora estamos en un contenedor, podemos instalar las bibliotecas CUDA necesarias, comprobando de nuevo la versión correcta de CUDA para su controlador aquí, aunque la salida anterior de nvidia-smi debería mostrar la versión de CUDA requerida. En el ejemplo siguiente, instale CUDA 12.3 y descargue muchos ejemplos, demostraciones y kits de desarrollo para que pueda validar completamente la GPU:
zypper ar https://developer.download.nvidia.com/compute/cuda/repos/sles15/x86_64/ cuda-suse
zypper in -y cuda-libraries-devel-12-3 cuda-minimal-build-12-3 cuda-demo-suite-12-3Una vez que se haya instalado correctamente, no salga del contenedor. Ejecutaremos el ejemplo de CUDA deviceQuery, que valida exhaustivamente el acceso a la GPU a través de CUDA, y desde dentro del propio contenedor:
/usr/local/cuda-12/extras/demo_suite/deviceQuerySi tiene éxito, debería ver una salida que muestre algo similar a lo siguiente, observando el mensaje Result = PASS al final del comando, y observando que en la salida a continuación, el sistema identifica correctamente dos GPU, mientras que su entorno puede tener solo una:
/usr/local/cuda-12/extras/demo_suite/deviceQuery Starting...
CUDA Device Query (Runtime API) version (CUDART static linking)
Detected 2 CUDA Capable device(s)
Device 0: "NVIDIA A100-PCIE-40GB"
CUDA Driver Version / Runtime Version 12.2 / 12.1
CUDA Capability Major/Minor version number: 8.0
Total amount of global memory: 40339 MBytes (42298834944 bytes)
(108) Multiprocessors, ( 64) CUDA Cores/MP: 6912 CUDA Cores
GPU Max Clock rate: 1410 MHz (1.41 GHz)
Memory Clock rate: 1215 Mhz
Memory Bus Width: 5120-bit
L2 Cache Size: 41943040 bytes
Maximum Texture Dimension Size (x,y,z) 1D=(131072), 2D=(131072, 65536), 3D=(16384, 16384, 16384)
Maximum Layered 1D Texture Size, (num) layers 1D=(32768), 2048 layers
Maximum Layered 2D Texture Size, (num) layers 2D=(32768, 32768), 2048 layers
Total amount of constant memory: 65536 bytes
Total amount of shared memory per block: 49152 bytes
Total number of registers available per block: 65536
Warp size: 32
Maximum number of threads per multiprocessor: 2048
Maximum number of threads per block: 1024
Max dimension size of a thread block (x,y,z): (1024, 1024, 64)
Max dimension size of a grid size (x,y,z): (2147483647, 65535, 65535)
Maximum memory pitch: 2147483647 bytes
Texture alignment: 512 bytes
Concurrent copy and kernel execution: Yes with 3 copy engine(s)
Run time limit on kernels: No
Integrated GPU sharing Host Memory: No
Support host page-locked memory mapping: Yes
Alignment requirement for Surfaces: Yes
Device has ECC support: Enabled
Device supports Unified Addressing (UVA): Yes
Device supports Compute Preemption: Yes
Supports Cooperative Kernel Launch: Yes
Supports MultiDevice Co-op Kernel Launch: Yes
Device PCI Domain ID / Bus ID / location ID: 0 / 23 / 0
Compute Mode:
< Default (multiple host threads can use ::cudaSetDevice() with device simultaneously) >
Device 1: <snip to reduce output for multiple devices>
< Default (multiple host threads can use ::cudaSetDevice() with device simultaneously) >
> Peer access from NVIDIA A100-PCIE-40GB (GPU0) -> NVIDIA A100-PCIE-40GB (GPU1) : Yes
> Peer access from NVIDIA A100-PCIE-40GB (GPU1) -> NVIDIA A100-PCIE-40GB (GPU0) : Yes
deviceQuery, CUDA Driver = CUDART, CUDA Driver Version = 12.3, CUDA Runtime Version = 12.3, NumDevs = 2, Device0 = NVIDIA A100-PCIE-40GB, Device1 = NVIDIA A100-PCIE-40GB
Result = PASSDesde aquí, puede continuar ejecutando cualquier otra carga de trabajo de CUDA: utilice compiladores y cualquier otro aspecto del ecosistema CUDA para realizar más pruebas. Cuando haya terminado, puede salir del contenedor, teniendo en cuenta que todo lo que haya instalado allí es efímero (¡así que se perderá!) y no ha afectado al sistema operativo subyacente:
exit30.5 Implementación con Kubernetes #
Ahora que hemos probado la instalación y el uso del controlador abierto de NVIDIA en SUSE Linux Micro, exploremos la configuración de Kubernetes en la misma máquina. Esta guía no le explica cómo desplegar Kubernetes, pero asume que ha instalado K3s o RKE2 y que su kubeconfig está configurado en consecuencia, de modo que los comandos estándar de kubectl se puedan ejecutar como superusuario. Asumimos que su nodo forma un clúster de un solo nodo, aunque los pasos principales deberían ser similares para clústeres de varios nodos. Primero, asegúrese de que su acceso a kubectl funciona:
kubectl get nodesEsto debería mostrar algo similar a lo siguiente:
NAME STATUS ROLES AGE VERSION
node0001 Ready control-plane,etcd,master 13d v1.35.4+rke2r1Lo que debería encontrar es que su instalación de k3s/rke2 ha detectado el NVIDIA Container Toolkit en el host y ha autoconfigurado la integración del entorno de ejecución de NVIDIA en containerd (la interfaz de entorno de ejecución de contenedor que utilizan k3s/rke2). Confírmelo comprobando el archivo config.toml de containerd:
tail -n8 /var/lib/rancher/rke2/agent/etc/containerd/config.tomlEsto debe mostrar algo parecido a lo siguiente. La ubicación equivalente de K3s es /var/lib/rancher/k3s/agent/etc/containerd/config.toml:
[plugins."io.containerd.grpc.v1.cri".containerd.runtimes."nvidia"]
runtime_type = "io.containerd.runc.v2"
[plugins."io.containerd.grpc.v1.cri".containerd.runtimes."nvidia".options]
BinaryName = "/usr/bin/nvidia-container-runtime"Si estas entradas no están presentes, es posible que la detección haya fallado. Esto podría deberse a que la máquina o los servicios de Kubernetes no se han reiniciado. Añada estos manualmente como se indica arriba, si es necesario.
A continuación, debemos configurar NVIDIA RuntimeClass como un tiempo de ejecución de Kubernetes adicional al predeterminado, asegurando que cualquier solicitud de usuario para pods que necesiten acceso a la GPU pueda utilizar el NVIDIA Container Toolkit para hacerlo, a través de nvidia-container-runtime, tal como se configura en la configuración de containerd:
kubectl apply -f - <<EOF
apiVersion: node.k8s.io/v1
kind: RuntimeClass
metadata:
name: nvidia
handler: nvidia
EOFEl siguiente paso es configurar NVIDIA Device Plugin, que configura Kubernetes para aprovechar las GPUs de NVIDIA como recursos dentro del clúster que se pueden utilizar, trabajando en combinación con el NVIDIA Container Toolkit. Esta herramienta detecta inicialmente todas las capacidades del host subyacente, incluidas las GPUs, los controladores y otras capacidades (como GL) y, a continuación, le permite solicitar recursos de GPU y consumirlos como parte de sus aplicaciones.
En primer lugar, debe añadir y actualizar el repositorio de Helm para el NVIDIA Device Plugin:
helm repo add nvdp https://nvidia.github.io/k8s-device-plugin
helm repo updateAhora puede instalar el NVIDIA Device Plugin:
helm upgrade -i nvdp nvdp/nvidia-device-plugin --namespace nvidia-device-plugin --create-namespace --version 0.14.5 --set runtimeClassName=nvidiaDespués de unos minutos, verá un nuevo pod en ejecución que completará la detección en sus nodos disponibles y los etiquetará con el número de GPUs que se han detectado:
kubectl get pods -n nvidia-device-plugin
NAME READY STATUS RESTARTS AGE
nvdp-nvidia-device-plugin-jp697 1/1 Running 2 (12h ago) 6d3h
kubectl get node node0001 -o json | jq .status.capacity
{
"cpu": "128",
"ephemeral-storage": "466889732Ki",
"hugepages-1Gi": "0",
"hugepages-2Mi": "0",
"memory": "32545636Ki",
"nvidia.com/gpu": "1", <----
"pods": "110"
}Ahora está listo para crear un pod de NVIDIA que intente utilizar esta GPU. Probemos con el contenedor CUDA Benchmark:
kubectl apply -f - <<EOF
apiVersion: v1
kind: Pod
metadata:
name: nbody-gpu-benchmark
namespace: default
spec:
restartPolicy: OnFailure
runtimeClassName: nvidia
containers:
- name: cuda-container
image: nvcr.io/nvidia/k8s/cuda-sample:nbody
args: ["nbody", "-gpu", "-benchmark"]
resources:
limits:
nvidia.com/gpu: 1
env:
- name: NVIDIA_VISIBLE_DEVICES
value: all
- name: NVIDIA_DRIVER_CAPABILITIES
value: all
EOFSi todo ha ido bien, puede consultar los registros y ver la información de la prueba de rendimiento:
kubectl logs nbody-gpu-benchmark
Run "nbody -benchmark [-numbodies=<numBodies>]" to measure performance.
-fullscreen (run n-body simulation in fullscreen mode)
-fp64 (use double precision floating point values for simulation)
-hostmem (stores simulation data in host memory)
-benchmark (run benchmark to measure performance)
-numbodies=<N> (number of bodies (>= 1) to run in simulation)
-device=<d> (where d=0,1,2.... for the CUDA device to use)
-numdevices=<i> (where i=(number of CUDA devices > 0) to use for simulation)
-compare (compares simulation results running once on the default GPU and once on the CPU)
-cpu (run n-body simulation on the CPU)
-tipsy=<file.bin> (load a tipsy model file for simulation)
NOTE: The CUDA Samples are not meant for performance measurements. Results may vary when GPU Boost is enabled.
> Windowed mode
> Simulation data stored in video memory
> Single precision floating point simulation
> 1 Devices used for simulation
GPU Device 0: "Turing" with compute capability 7.5
> Compute 7.5 CUDA device: [Tesla T4]
40960 bodies, total time for 10 iterations: 101.677 ms
= 165.005 billion interactions per second
= 3300.103 single-precision GFLOP/s at 20 flops per interactionPor último, si sus aplicaciones requieren OpenGL, puede instalar las bibliotecas de NVIDIA OpenGL necesarias a nivel de host, y el NVIDIA Device Plugin y el NVIDIA Container Toolkit pueden ponerlas a disposición de los contenedores. Para ello, instale el paquete de la siguiente manera:
transactional-update pkg install nvidia-gl-G06Debe reiniciar para que este paquete esté disponible para sus aplicaciones. El NVIDIA Device Plugin debería redetectarlo automáticamente a través del NVIDIA Container Toolkit.
30.6 Integración a través de Edge Image Builder #
Bien, ya ha demostrado la funcionalidad completa de sus aplicaciones y GPUs en SUSE Linux Micro y ahora desea utilizar Capítulo 8, Edge Image Builder para proporcionarlo todo en conjunto mediante una imagen de disco ISO o RAW lista para desplegar o consumir. Esta guía no explica cómo utilizar Edge Image Builder, pero proporciona la configuración necesaria para crear dicha imagen. A continuación puede encontrar un ejemplo de una definición de imagen, junto con los archivos de configuración de Kubernetes necesarios, para garantizar que todos los componentes requeridos se desplieguen automáticamente. Esta es la estructura de directorios del directorio de Edge Image Builder para el ejemplo que se muestra a continuación:
.
├── base-images
│ └── SL-Micro.x86_64-6.2-Base-SelfInstall-GM.install.iso
├── eib-config-iso.yaml
├── kubernetes
│ ├── config
│ │ └── server.yaml
│ ├── helm
│ │ └── values
│ │ └── nvidia-device-plugin.yaml
│ └── manifests
│ └── nvidia-runtime-class.yaml
└── rpms
└── gpg-keys
└── nvidia-container-toolkit.keyExploremos esos archivos. En primer lugar, aquí tiene una definición de imagen de ejemplo para un clúster de un solo nodo que ejecuta K3s y que también despliega las utilidades y los paquetes de OpenGL (eib-config-iso.yaml):
apiVersion: 1.3
image:
arch: x86_64
imageType: iso
baseImage: SL-Micro.x86_64-6.2-Base-SelfInstall-GM.install.iso
outputImageName: deployimage.iso
operatingSystem:
time:
timezone: Europe/London
ntp:
pools:
- 2.suse.pool.ntp.org
isoConfiguration:
installDevice: /dev/sda
users:
- username: root
encryptedPassword: $6$XcQN1xkuQKjWEtQG$WbhV80rbveDLJDz1c93K5Ga9JDjt3mF.ZUnhYtsS7uE52FR8mmT8Cnii/JPeFk9jzQO6eapESYZesZHO9EslD1
packages:
packageList:
- nvidia-open-driver-G06-signed-kmp-default
- nvidia-compute-utils-G06
- nvidia-gl-G06
- nvidia-container-toolkit
additionalRepos:
- url: https://download.nvidia.com/suse/sle15sp6/
- url: https://nvidia.github.io/libnvidia-container/stable/rpm/x86_64
sccRegistrationCode: [snip]
kubernetes:
version: v1.35.4+k3s1
helm:
charts:
- name: nvidia-device-plugin
version: v0.14.5
installationNamespace: kube-system
targetNamespace: nvidia-device-plugin
createNamespace: true
valuesFile: nvidia-device-plugin.yaml
repositoryName: nvidia
repositories:
- name: nvidia
url: https://nvidia.github.io/k8s-device-pluginEsto es solo un ejemplo. Es posible que deba personalizarlo para adaptarlo a sus requisitos y expectativas. Además, si utiliza SUSE Linux Micro, debe proporcionar su propio sccRegistrationCode para resolver las dependencias de los paquetes y extraer los controladores de NVIDIA.
Además de esto, necesitamos añadir componentes adicionales para que Kubernetes los cargue en el momento del arranque. El directorio EIB necesita primero un directorio kubernetes, con subdirectorios para la configuración, los valores del chart de Helm y cualquier manifiesto adicional requerido:
mkdir -p kubernetes/config kubernetes/helm/values kubernetes/manifestsConfiguremos ahora la configuración (opcional) de Kubernetes eligiendo un CNI (que utiliza Cilium por defecto si no se selecciona) y habilitando SELinux:
cat << EOF > kubernetes/config/server.yaml
cni: cilium
ingress-controller: traefik
selinux: true
EOFAhora asegúrese de que la RuntimeClass de NVIDIA se cree en el clúster de Kubernetes:
cat << EOF > kubernetes/manifests/nvidia-runtime-class.yaml
apiVersion: node.k8s.io/v1
kind: RuntimeClass
metadata:
name: nvidia
handler: nvidia
EOFUtilizamos el controlador de Helm integrado para desplegar el complemento de dispositivo NVIDIA a través del propio Kubernetes. Proporcionemos la clase de tiempo de ejecución en el archivo de valores del chart:
cat << EOF > kubernetes/helm/values/nvidia-device-plugin.yaml
runtimeClassName: nvidia
EOFNecesitamos obtener la clave pública RPM del NVIDIA Container Toolkit antes de continuar:
mkdir -p rpms/gpg-keys
curl -o rpms/gpg-keys/nvidia-container-toolkit.key https://nvidia.github.io/libnvidia-container/gpgkeyTodos los artefactos necesarios, incluidos el binario de Kubernetes, las imágenes de contenedor, los charts de Helm (y cualquier imagen referenciada), se incluirán automáticamente en un entorno aislado, lo que significa que los sistemas en el momento del despliegue no deberían requerir conectividad a Internet por defecto. Ahora solo necesita obtener la ISO de SUSE Linux Micro de la Página de Descargas de SUSE (y colocarla en el directorio base-images), y puede ejecutar la herramienta Edge Image Builder para generar la ISO por usted. Para completar el ejemplo, aquí está el comando que se utilizó para compilar la imagen:
podman run --rm --privileged -it -v /path/to/eib-files/:/eib \
registry.suse.com/edge/3.6/edge-image-builder:1.3.3.1 \
build --definition-file eib-config-iso.yamlPara obtener más instrucciones, consulte la documentación de Edge Image Builder.
30.7 Resolución de problemas #
30.7.1 nvidia-smi no encuentra la GPU #
Compruebe los mensajes del kernel utilizando dmesg. Si esto indica que no puede asignar NvKMSKapDevice, aplique la solución alternativa para GPU no admitidas:
sed -i '/NVreg_OpenRmEnableUnsupportedGpus/s/^#//g' /etc/modprobe.d/50-nvidia-default.confNOTA: Deberá volver a cargar el módulo del kernel, o reiniciar, si cambia la configuración del módulo del kernel en el paso anterior para que tenga efecto.
