Esta página se ha traducido con Cloud Translation API.

Desplegar Gemma con Ollama y Open WebUI

Con las GPUs de NVIDIA de nivel empresarial incluidas en la SKU optimizada para IA de GDC Sandbox, puedes desarrollar y probar aplicaciones exigentes de entrenamiento e inferencia de IA, como la IA generativa.

Gemma es un modelo de lenguaje extenso ligero basado en la tecnología de Gemini. En esta guía se explica cómo desplegar Gemma con Ollama y Open-WebUI en el sandbox de GDC. Además, se indican los siguientes objetivos.

Despliega Ollama con el modelo Gemma en un sandbox de GDC optimizado para IA con GPUs.
Envía peticiones al servicio Ollama en su endpoint privado a través de la interfaz de Open WebUI.

Antes de empezar

Las GPUs del entorno aislado de GDC se incluyen en el clúster org-infra.

Para ejecutar comandos en el clúster de infraestructura de la organización, asegúrate de tener el archivo kubeconfig del clúster org-1-infra, tal como se describe en Trabajar con clústeres:
- Configurar y autenticar con la línea de comandos gdcloud
- Genera el archivo kubeconfig del clúster de infraestructura de la organización y asigna su ruta a la variable de entorno KUBECONFIG.
Asegúrate de que el usuario tenga asignado el rol sandbox-gpu-admin en el proyecto sandbox-gpu-project. De forma predeterminada, el rol se asigna al usuario platform-admin. Para asignar el rol a otros usuarios, inicia sesión como platform-admin y ejecuta el siguiente comando:
```
kubectl --kubeconfig ${KUBECONFIG} create rolebinding ${NAME} --role=sandbox-gpu-admin \
--user=${USER} --namespace=sandbox-gpu-project
```
Configura el repositorio de Artifact Registry tal como se describe en el artículo Usar Artifact Registry e inicia sesión para poder enviar y extraer imágenes del registro de artefactos.

Desplegar el modelo Gemma con Ollama y Open WebUI

El despliegue se coordina mediante un conjunto de archivos de configuración de Kubernetes (manifiestos YAML), cada uno de los cuales define un componente o servicio específico.

Crea un Dockerfile con Gemma predescargado.

 FROM ubuntu

 # Install Ollama
 # This uses Ollamas official installation script, which adds Ollama to /usr/local/bin
 RUN apt-get update && apt-get install -y --no-install-recommends curl ca-certificates
 RUN curl -fsSL https://ollama.com/install.sh -o install.sh
 RUN chmod +x install.sh
 RUN ./install.sh && \
     rm -rf /var/lib/apt/lists/*

 # Set environment variables for Ollama (optional, but good practice)
 ENV OLLAMA_HOST="0.0.0.0"
 # ENV OLLAMA_MODELS="/usr/local/ollama/models" # Default is /root/.ollama
 # If you want to customize the model storage path within the container, set OLLAMA_MODELS
 # and then ensure you create and populate that directory. Default is usually fine for pre-downloaded.

 # --- Predownload Gemma Model ---
 # This step starts Ollama server in the background, pulls the model,
 # and then kills the server to allow the Docker build to continue.
 # This approach works around Docker''s RUN command limitations for services.

 RUN ollama serve & \
     sleep 5 && \
     # Give the Ollama server a moment to start up
     # Use --retry and --retry-connrefused to handle startup delays
     curl --retry 10 --retry-connrefused -s http://localhost:11434 || true && \
     echo "Attempting to pull gemma:7b..." && \
     ollama pull gemma:7b && \
     echo "Model pull complete. Cleaning up background Ollama process." && \
     pkill ollama || true # Gracefully kill the ollama serve process

 # Expose Ollama's default port
 EXPOSE 11434

 # Command to run Ollama server when the container starts
 CMD ["ollama", "serve"]

Crea la imagen de Docker y súbela al repositorio de Artifact Registry.

docker build -t ollama-gemma .
docker tag ollama-gemma REGISTRY_REPOSITORY_URL/ollama-gemma:latest
docker push REGISTRY_REPOSITORY_URL/ollama-gemma:latest

Haz los cambios siguientes:

REGISTRY_REPOSITORY_URL con la URL del repositorio.

Crea un secreto para guardar las credenciales de Docker.


export SECRET=DOCKER_REGISTRY_SECRET
export DOCKER_TEST_CONFIG=~/.docker/config.json 
kubectl --kubeconfig ${KUBECONFIG}$ create secret docker-registry ${SECRET} --from-file=.dockerconfigjson=${DOCKER_TEST_CONFIG} -n sandbox-gpu-project

Haz los cambios siguientes:

DOCKER_REGISTRY_SECRET Nombre del secreto.

Crea un archivo ollama-deployment.yaml para definir la implementación del motor de IA Ollama:

La implementación del servidor Ollama requiere una GPU.

  apiVersion: apps/v1
  kind: Deployment
  metadata:
    annotations:
      deployment.kubernetes.io/revision: "9"
    name: ollama
    namespace: sandbox-gpu-project
  spec:
    progressDeadlineSeconds: 600
    replicas: 1
    revisionHistoryLimit: 10
    selector:
      matchLabels:
        app: ollama
    strategy:
      rollingUpdate:
        maxSurge: 25%
        maxUnavailable: 25%
      type: RollingUpdate
    template:
      metadata:
        creationTimestamp: null
        labels:
          app: ollama
          egress.networking.gke.io/enabled: "true"
      spec:
        containers:
          - name: ollama
            image: REGISTRY_REPOSITORY_URL/ollama-gemma:latest
            imagePullPolicy: Always
            ports:
              - containerPort: 11434
                protocol: TCP
            resources:
              limits:
                nvidia.com/gpu-pod-NVIDIA_H100_80GB_HBM3: "1"
              requests:
                nvidia.com/gpu-pod-NVIDIA_H100_80GB_HBM3: "1"
            env:
              - name: OLLAMA_HOST
                value: 0.0.0.0
              - name: OLLAMA_ORIGINS
                value: http://localhost:8080,http://ollama-webui.ollama-llm.svc.cluster.local:8080,http://ollama-webui:8080
            securityContext:
              seLinuxOptions:
                type: unconfined_t
            terminationMessagePath: /dev/termination-log
            terminationMessagePolicy: File
        imagePullSecrets:
        - name: DOCKER_REGISTRY_SECRET
        dnsConfig:
          nameservers:
            - 8.8.8.8
        dnsPolicy: ClusterFirst
        restartPolicy: Always
        schedulerName: default-scheduler
        terminationGracePeriodSeconds: 30

Haz los cambios siguientes:

REGISTRY_REPOSITORY_URL: URL del repositorio.
DOCKER_REGISTRY_SECRET: nombre del secreto.

Crea el archivo ollama-service.yaml para exponer el servidor de Ollama internamente.

apiVersion: v1
kind: Service
metadata:
  name: ollama
  namespace: sandbox-gpu-project
  annotations:
    metallb.universe.tf/ip-allocated-from-pool: lb-address-pool-0-ptleg
spec:
  type: LoadBalancer
  selector:
    app: ollama
  ports:
    - port: 11434
      nodePort: 30450
  ipFamilyPolicy: SingleStack
  ipFamilies:
    - IPv4
  clusterIPs:
    - 10.1.122.216
  clusterIP: 10.1.122.216

Aplica los archivos de manifiesto

kubectl --kubeconfig ${KUBECONFIG} apply -f ollama-deployment.yaml
kubectl --kubeconfig ${KUBECONFIG} apply -f ollama-service.yaml

Asegúrate de que los pods de ollama se estén ejecutando.

kubectl --kubeconfig ${KUBECONFIG} get deployments -n sandbox-gpu-project
kubectl --kubeconfig ${KUBECONFIG} get service -n sandbox-gpu-project

Anota la IP externa del servicio Ollama OLLAMA_BASE_END_POINT en el resultado.

kubectl --kubeconfig ${KUBECONFIG} get service ollama \
      -n sandbox-gpu-project -o jsonpath='{.status.loadBalancer.ingress[*].ip}'

Crea el archivo openweb-ui-deployment.yaml para implementar la interfaz de Open WebUI.

  apiVersion: apps/v1
  kind: Deployment
  metadata:
    name: ollama-webui
    namespace: sandbox-gpu-project
    labels:
      app: ollama-webui
    annotations:
      deployment.kubernetes.io/revision: "5"
  spec:
    replicas: 1
    selector:
      matchLabels:
        app: ollama-webui
    strategy:
      type: RollingUpdate
      rollingUpdate:
        maxSurge: 25%
        maxUnavailable: 25%
    progressDeadlineSeconds: 600
    revisionHistoryLimit: 10
    template:
      metadata:
        labels:
          app: ollama-webui
        creationTimestamp: null
      spec:
        containers:
          - name: ollama-webui
            image: ghcr.io/open-webui/open-webui:main
            imagePullPolicy: IfNotPresent
            ports:
              - name: http
                containerPort: 8080
                protocol: TCP
            env:
              - name: OLLAMA_BASE_URL
                value: OLLAMA_BASE_END_POINT
              - name: PORT
                value: "8080"
            terminationMessagePath: /dev/termination-log
            terminationMessagePolicy: File
        restartPolicy: Always
        dnsPolicy: ClusterFirst
        schedulerName: default-scheduler
        terminationGracePeriodSeconds: 30

Haz los cambios siguientes:

OLLAMA_BASE_END_POINT: la dirección IP externa del servicio Ollama.

Crea un archivo ollama-webui-service.yaml para exponer externamente la interfaz webui abierta.

apiVersion: v1
kind: Service
metadata:
  name: ollama-webui
  namespace: sandbox-gpu-project
  annotations:
    metallb.universe.tf/ip-allocated-from-pool: lb-address-pool-0-ptleg
spec:
  type: LoadBalancer
  ipFamilyPolicy: SingleStack
  ipFamilies:
  - IPv4
  clusterIPs:
  - 10.1.104.52
  clusterIP: 10.1.104.52
  ports:
  - port: 80
    targetPort: 8080
    nodePort: 32351
  selector:
    app: ollama-webui

Aplica los manifiestos openweb-ui-deployment.yaml y ollama-webui-service.yaml al clúster.

    kubectl --kubeconfig ${KUBECONFIG} apply -f openweb-ui-deployment.yaml
    kubectl --kubeconfig ${KUBECONFIG} apply -f ollama-webui-service.yaml

Crea una política de red de proyecto para permitir el tráfico entrante de direcciones IP externas.

kubectl --kubeconfig ${KUBECONFIG} apply -f - <<EOF
apiVersion: networking.global.gdc.goog/v1
kind: ProjectNetworkPolicy
metadata:
  namespace: sandbox-gpu-project
  name: allow-inbound-traffic-from-external
spec:
  policyType: Ingress
  subject:
    subjectType: UserWorkload
  ingress:
  - from:
    - ipBlock:
        cidr: 0.0.0.0/0
EOF

Identifica la IP externa del servicio Ollama ejecutando el siguiente comando. Anota este valor para usarlo en pasos posteriores, donde lo sustituirás por OPEN_WEB_UI_ENDPOINT.
```
kubectl --kubeconfig ${KUBECONFIG} get service -n sandbox-gpu-project
```
Abre Google Chrome e introduce la URL con la dirección IP externa que has encontrado en el paso anterior. Ahora puedes interactuar con el modelo Gemma a través de la interfaz de usuario web abierta.
```
http://OPEN_WEB_UI_ENDPOINT/
```

Desplegar Gemma con Ollama y Open WebUI Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Antes de empezar

Desplegar el modelo Gemma con Ollama y Open WebUI

Desplegar Gemma con Ollama y Open WebUI