Questa pagina è stata tradotta dall'API Cloud Translation.

Deployment di Gemma utilizzando Ollama e Open WebUI

Con le GPU NVIDIA di livello enterprise incluse nello SKU ottimizzato per l'AI di GDC Sandbox, puoi sviluppare e testare applicazioni di inferenza e addestramento AI impegnative, come l'AI generativa.

Gemma è un modello linguistico di grandi dimensioni leggero basato sulla tecnologia Gemini. Questa guida tutorial mostra come eseguire il deployment di Gemma con Ollama e Open-WebUI in GDC Sandbox e ha i seguenti obiettivi.

Esegui il deployment di Ollama con il modello Gemma in una sandbox GDC ottimizzata per l'AI con GPU.
Invia prompt al servizio Ollama sul relativo endpoint privato tramite l'interfaccia Open-WebUI.

Prima di iniziare

Le GPU in GDC Sandbox sono incluse nel cluster org-infra.

Per eseguire comandi sul cluster di infrastruttura dell'organizzazione, assicurati di disporre del kubeconfig del cluster org-1-infra, come descritto in Utilizzare i cluster:
- Configura ed esegui l'autenticazione con la riga di comando gdcloud e
- genera il file kubeconfig per il cluster di infrastruttura dell'organizzazione e assegna il relativo percorso alla variabile di ambiente KUBECONFIG.
Assicurati che all'utente sia assegnato il ruolo sandbox-gpu-admin per il progetto sandbox-gpu-project. Per impostazione predefinita, il ruolo viene assegnato all'utente platform-admin. Puoi assegnare il ruolo ad altri utenti accedendo come platform-admin ed eseguendo questo comando:
```
kubectl --kubeconfig ${KUBECONFIG} create rolebinding ${NAME} --role=sandbox-gpu-admin \
--user=${USER} --namespace=sandbox-gpu-project
```
Assicurati di configurare il repository Artifact Registry come descritto nella sezione Utilizzo di Artifact Registry e accedi per poter eseguire il push e il pull delle immagini nel registro degli artefatti.

Esegui il deployment del modello Gemma con Ollama e Open WebUI

Il deployment viene orchestrato tramite un insieme di file di configurazione Kubernetes (manifest YAML), ognuno dei quali definisce un componente o un servizio specifico.

Crea un Dockerfile con Gemma pre-scaricato.

 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 l'immagine Docker e caricala nel repository 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

Sostituisci quanto segue:

REGISTRY_REPOSITORY_URL con l'URL del repository.

Crea un secret per salvare le credenziali 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

Sostituisci quanto segue:

DOCKER_REGISTRY_SECRET nome del secret.

Crea un file ollama-deployment.yaml per definire il deployment del motore AI Ollama:

Il deployment del server Ollama richiede 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

Sostituisci quanto segue:

REGISTRY_REPOSITORY_URL: l'URL del repository.
DOCKER_REGISTRY_SECRET: il nome del secret.

Crea il file ollama-service.yaml per esporre internamente il server Ollama.

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

Applica i manifest

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

Assicurati che i pod di ollama siano in esecuzione.

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

Prendi nota dell'IP esterno del servizio Ollama OLLAMA_BASE_END_POINT dall'output.

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

Crea il file openweb-ui-deployment.yaml per eseguire il deployment dell'interfaccia 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

Sostituisci quanto segue:

OLLAMA_BASE_END_POINT: l'indirizzo IP esterno del servizio Ollama.

Crea un file ollama-webui-service.yaml per esporre esternamente l'interfaccia webui aperta.

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

Applica i manifest openweb-ui-deployment.yaml e ollama-webui-service.yaml al cluster.

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

Crea un criterio di rete del progetto per consentire il traffico in entrata da indirizzi IP esterni.

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 l'IP esterno del servizio Ollama eseguendo questo comando. Prendi nota di questo valore per utilizzarlo nei passaggi successivi, in cui lo sostituirai a OPEN_WEB_UI_ENDPOINT.
```
kubectl --kubeconfig ${KUBECONFIG} get service -n sandbox-gpu-project
```
Apri Google Chrome e inserisci l'URL utilizzando l'indirizzo IP esterno che hai trovato nel passaggio precedente. Ora puoi interagire con il modello Gemma tramite l'interfaccia utente Open Web UI.
```
http://OPEN_WEB_UI_ENDPOINT/
```

Deployment di Gemma utilizzando Ollama e Open WebUI Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Prima di iniziare

Esegui il deployment del modello Gemma con Ollama e Open WebUI

Deployment di Gemma utilizzando Ollama e Open WebUI