Déployer sur un cluster Kubernetes isolé du réseau

​

Introduction

• Installations gouvernementales sécurisées.
• Institutions financières soumises à une isolation réseau stricte.
• Organismes de santé soumis à des exigences de conformité.
• Environnements de systèmes de contrôle industriels (ICS).
• Centres de recherche disposant de réseaux classifiés.

​

Prérequis

​

Exigences de version

​

Exigences SSL/TLS

​

Exigences matérielles

​

Base de données MySQL

• AWS RDS Aurora MySQL
• Google Cloud SQL for MySQL
• Azure Database for MySQL

​

Redis

• Amazon ElastiCache
• Google Cloud Memorystore
• Azure Cache for Redis
• Redis auto-hébergé dans votre infrastructure cloud ou sur site

​

Stockage d’objets

• Amazon S3 : service de stockage d’objets offrant évolutivité, disponibilité des données, sécurité et performances.
• Google Cloud Storage : service géré de stockage de données non structurées à grande échelle.
• Azure Blob Storage : stockage d’objets dans le cloud pour les données non structurées à grande échelle.
• CoreWeave AI Object Storage : stockage d’objets compatible S3, optimisé pour les charges de travail d’IA.
• Stockage d’entreprise compatible S3, tel que MinIO Enterprise (AIStor), NetApp StorageGRID ou d’autres solutions d’entreprise.

​

Exigences spécifiques aux environnements isolés du réseau

• Registre de conteneurs interne : accès à un registre de conteneurs privé tel que Harbor, JFrog Artifactory ou Nexus, contenant toutes les images W&B requises.
• Dépôt Helm interne : accès à un dépôt de charts Helm privé contenant les charts Helm W&B.
• Moyen de transfert d’images : une méthode permettant de transférer des images de conteneur depuis un système connecté à Internet vers votre registre isolé du réseau.
• Fichier de licence : une licence W&B Enterprise valide. Pour obtenir une licence (par exemple depuis une machine connectée à Internet), consultez la section License de la page des exigences, ou contactez votre équipe de compte W&B.

​

Préparer votre environnement isolé du réseau

​

Étape 1 : Configurer un registre de conteneurs interne

​

Conteneurs des composants principaux de W&B

• docker.io/wandb/controller : opérateur Kubernetes W&B.
• docker.io/wandb/local : serveur d’applications W&B.
• docker.io/wandb/console : console d’administration W&B.
• docker.io/wandb/megabinary : microservices W&B (API, executor, glue, parquet).

​

Conteneurs de dépendances

• docker.io/bitnamilegacy/redis : requise pour le déploiement local de Redis lors des tests et du développement. Pour connaître les exigences relatives à Redis en production, consultez la section Redis des prérequis.
• docker.io/otel/opentelemetry-collector-contrib : agent OpenTelemetry chargé de collecter les métriques et les journaux.
• quay.io/prometheus/prometheus : Prometheus, pour la collecte des métriques.
• quay.io/prometheus-operator/prometheus-config-reloader : dépendance de Prometheus.

​

Obtenir la liste complète des images

1. Sur un système connecté à Internet, téléchargez les charts Helm W&B depuis le dépôt des charts Helm W&B :
   # Cloner le dépôt helm-charts
   git clone https://github.com/wandb/helm-charts.git
   cd helm-charts
   
2. Examinez les fichiers values.yaml pour identifier toutes les images de conteneur et leurs versions :
   # Extraire les références d'images du chart de l'opérateur
   helm show values charts/operator | grep -E "repository:|tag:" | grep -v "^#"
   
   # Extraire les références d'images du chart de la plateforme
   helm show values charts/operator-wandb | grep -E "repository:|tag:" | grep -v "^#"
   
   Vous pouvez également utiliser cette commande pour extraire uniquement les noms de dépôts (sans les tags de version) :
   helm show values charts/operator-wandb \
     | awk -F': *' '/^[[:space:]]*repository:/{print $2}' \
     | grep -v "^#" \
     | sort -u
   
   La liste des dépôts se présente comme suit :
   wandb/controller
   wandb/local
   wandb/console
   wandb/megabinary
   wandb/weave-python
   wandb/weave-trace
   otel/opentelemetry-collector-contrib
   prometheus/prometheus
   prometheus-operator/prometheus-config-reloader
   bitnamilegacy/redis
   
   Pour obtenir le tag de version précis de chaque image, utilisez la première commande ci-dessus (grep -E "repository:|tag:"), qui affiche à la fois les noms de dépôts et les tags de version correspondants.

​

Transférer les images vers le registre isolé du réseau

1. Sur un système connecté à Internet, récupérez (pull) et enregistrez toutes les images requises.
   Dans les exemples suivants, remplacez les numéros de version par les versions réelles relevées lors de l’inspection de votre chart Helm à l’étape précédente. Les versions indiquées ici ne sont que des exemples et deviendront obsolètes avec le temps.
   Utilisez des variables shell pour gérer les versions de manière cohérente :
   # Définir les variables de version (mettez-les à jour en fonction des versions de votre chart Helm)
   CONTROLLER_VERSION="1.13.3"
   APP_VERSION="0.59.2"
   CONSOLE_VERSION="2.12.2"
   
   # Récupérer les images
   docker pull wandb/controller:${CONTROLLER_VERSION}
   docker pull wandb/local:${APP_VERSION}
   docker pull wandb/console:${CONSOLE_VERSION}
   docker pull wandb/megabinary:${APP_VERSION}
   # ... récupérer toutes les autres images requises avec leurs versions
   
   # Enregistrer les images dans des fichiers .tar
   docker save wandb/controller:${CONTROLLER_VERSION} -o wandb-controller-${CONTROLLER_VERSION}.tar
   docker save wandb/local:${APP_VERSION} -o wandb-local-${APP_VERSION}.tar
   docker save wandb/console:${CONSOLE_VERSION} -o wandb-console-${CONSOLE_VERSION}.tar
   docker save wandb/megabinary:${APP_VERSION} -o wandb-megabinary-${APP_VERSION}.tar
   # ... enregistrer toutes les autres images
   
2. Transférez les fichiers .tar vers votre environnement isolé du réseau par la méthode approuvée au sein de votre organisation, par exemple une clé USB ou un transfert de fichiers sécurisé.
3. Dans votre environnement isolé du réseau, chargez les images et téléversez-les vers votre registre interne :
   # Définir les mêmes variables de version que ci-dessus
   CONTROLLER_VERSION="1.13.3"
   APP_VERSION="0.59.2"
   CONSOLE_VERSION="2.12.2"
   INTERNAL_REGISTRY="registry.yourdomain.com"
   
   # Charger les images
   docker load -i wandb-controller-${CONTROLLER_VERSION}.tar
   docker load -i wandb-local-${APP_VERSION}.tar
   docker load -i wandb-console-${CONSOLE_VERSION}.tar
   docker load -i wandb-megabinary-${APP_VERSION}.tar
   # ... charger toutes les autres images
   
   # Étiqueter pour le registre interne
   docker tag wandb/controller:${CONTROLLER_VERSION} ${INTERNAL_REGISTRY}/wandb/controller:${CONTROLLER_VERSION}
   docker tag wandb/local:${APP_VERSION} ${INTERNAL_REGISTRY}/wandb/local:${APP_VERSION}
   docker tag wandb/console:${CONSOLE_VERSION} ${INTERNAL_REGISTRY}/wandb/console:${CONSOLE_VERSION}
   docker tag wandb/megabinary:${APP_VERSION} ${INTERNAL_REGISTRY}/wandb/megabinary:${APP_VERSION}
   # ... étiqueter toutes les autres images
   
   # Téléverser vers le registre interne
   docker push ${INTERNAL_REGISTRY}/wandb/controller:${CONTROLLER_VERSION}
   docker push ${INTERNAL_REGISTRY}/wandb/local:${APP_VERSION}
   docker push ${INTERNAL_REGISTRY}/wandb/console:${CONSOLE_VERSION}
   docker push ${INTERNAL_REGISTRY}/wandb/megabinary:${APP_VERSION}
   # ... téléverser toutes les autres images
   

​

Étape 2 : Configurer un dépôt interne de charts Helm

• Chart W&B Operator
• Chart W&B Platform

1. Sur un système connecté à Internet, téléchargez les charts :
   # Ajouter le dépôt Helm W&B
   helm repo add wandb https://wandb.github.io/helm-charts
   helm repo update
   
   # Télécharger les charts
   helm pull wandb/operator --version 1.13.3
   helm pull wandb/operator-wandb --version 0.18.0
   
2. Transférez les fichiers de charts .tgz vers votre environnement isolé du réseau, puis téléversez-les dans votre dépôt Helm interne en suivant les procédures propres à ce dépôt. Le chart operator déploie l’opérateur Kubernetes W&B (gestionnaire de contrôleurs). Le chart operator-wandb déploie W&B Platform à partir des valeurs configurées dans la ressource personnalisée (CR).

​

Étape 3 : Configurer l’accès au dépôt Helm

1. Dans votre environnement isolé du réseau, configurez Helm pour qu’il utilise votre dépôt interne :
   helm repo add local-repo https://charts.yourdomain.com
   helm repo update
   
2. Vérifiez que les charts sont disponibles :
   helm search repo local-repo/operator
   helm search repo local-repo/operator-wandb
   

​

Déployer W&B dans un environnement isolé du réseau

​

Étape 4 : installer l’opérateur Kubernetes

1. Créez un fichier values.yaml avec le contenu suivant :
   image:
     repository: registry.yourdomain.com/wandb/controller
     tag: 1.13.3
   
   airgapped: true
   
   Remplacez le dépôt et le tag par les versions que vous avez réellement transférées vers votre registre interne à l’étape 1. La version indiquée ici (1.13.3) n’est qu’un exemple et finira par devenir obsolète.
2. Installez l’opérateur et la Custom Resource Definition (CRD) :
   helm upgrade --install operator local-repo/operator \
     --namespace wandb \
     --create-namespace \
     --values values.yaml
   
3. Vérifiez que l’opérateur est en cours d’exécution :
   kubectl get pods -n wandb
   
   Le pod de l’opérateur doit apparaître à l’état Running.

​

Étape 5 : configurer la base de données MySQL

CREATE USER 'wandb_local'@'%' IDENTIFIED BY '[PASSWORD]';
CREATE DATABASE wandb_local CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
GRANT ALL ON wandb_local.* TO 'wandb_local'@'%' WITH GRANT OPTION;

​

Étape 6 : configurer la Ressource personnalisée W&B

apiVersion: apps.wandb.com/v1
kind: WeightsAndBiases
metadata:
  labels:
    app.kubernetes.io/instance: wandb
    app.kubernetes.io/name: weightsandbiases
  name: wandb
  namespace: wandb

spec:
  chart:
    url: https://charts.yourdomain.com
    name: operator-wandb
    version: 0.18.0

  values:
    global:
      host: https://wandb.yourdomain.com
      license: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
      
      bucket:
        accessKey: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
        secretKey: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
        name: s3.yourdomain.com:9000
        path: wandb
        provider: s3
        region: us-east-1
      
      mysql:
        database: wandb
        host: mysql.yourdomain.com
        password: [YOUR-MYSQL-PASSWORD]
        port: 3306
        user: wandb
      
      redis:
        host: redis.yourdomain.com
        port: 6379
        password: [YOUR-REDIS-PASSWORD]
      
      api:
        enabled: true
      
      glue:
        enabled: true
      
      executor:
        enabled: true
      
      extraEnv:
        ENABLE_REGISTRY_UI: 'true'

    # Configurer les images de tous les composants pour qu’elles utilisent le registre interne
    app:
      image:
        repository: registry.yourdomain.com/wandb/local
        tag: 0.59.2

    console:
      image:
        repository: registry.yourdomain.com/wandb/console
        tag: 2.12.2

    api:
      image:
        repository: registry.yourdomain.com/wandb/megabinary
        tag: 0.59.2

    executor:
      image:
        repository: registry.yourdomain.com/wandb/megabinary
        tag: 0.59.2

    glue:
      image:
        repository: registry.yourdomain.com/wandb/megabinary
        tag: 0.59.2

    parquet:
      image:
        repository: registry.yourdomain.com/wandb/megabinary
        tag: 0.59.2

    weave:
      image:
        repository: registry.yourdomain.com/wandb/weave-python
        tag: 0.59.2

    otel:
      image:
        repository: registry.yourdomain.com/otel/opentelemetry-collector-contrib
        tag: 0.97.0

    prometheus:
      server:
        image:
          repository: registry.yourdomain.com/prometheus/prometheus
          tag: v2.47.0
      configmapReload:
        prometheus:
          image:
            repository: registry.yourdomain.com/prometheus-operator/prometheus-config-reloader
            tag: v0.67.0

    ingress:
      annotations:
        nginx.ingress.kubernetes.io/proxy-body-size: "0"
      class: nginx

• settingsMigrationJob
• weave-trace
• filestream
• flat-runs-table

​

Étape 7 : Déployer la W&B Platform

1. Appliquez la ressource personnalisée W&B pour déployer la plateforme :
   kubectl apply -f wandb.yaml
   
2. Surveillez la progression du déploiement :
   # Suivre la création des pods
   kubectl get pods -n wandb --watch
   
   # Vérifier le statut du déploiement
   kubectl get weightsandbiases -n wandb
   
   # Afficher les journaux de l’opérateur
   kubectl logs -n wandb deployment/wandb-operator-controller-manager
   
   Le déploiement peut prendre plusieurs minutes, le temps que l’opérateur crée tous les composants nécessaires.

​

Configuration d’OpenShift

​

Contraintes de contexte de sécurité OpenShift

​

Option 1 : utiliser la SCC restricted (recommandée)

spec:
  values:
    # Configurer les contextes de sécurité de tous les pods
    app:
      podSecurityContext:
        fsGroup: 1000
        runAsUser: 1000
        runAsNonRoot: true
      securityContext:
        allowPrivilegeEscalation: false
        capabilities:
          drop:
            - ALL
        runAsNonRoot: true
        seccompProfile:
          type: RuntimeDefault

    console:
      podSecurityContext:
        fsGroup: 1000
        runAsUser: 1000
        runAsNonRoot: true
      securityContext:
        allowPrivilegeEscalation: false
        capabilities:
          drop:
            - ALL
        runAsNonRoot: true
        seccompProfile:
          type: RuntimeDefault

    # Procéder de même pour les autres composants : api, executor, glue, parquet, weave

​

Option 2 : créer une SCC personnalisée (si nécessaire)

apiVersion: security.openshift.io/v1
kind: SecurityContextConstraints
metadata:
  name: wandb-scc
allowHostDirVolumePlugin: false
allowHostIPC: false
allowHostNetwork: false
allowHostPID: false
allowHostPorts: false
allowPrivilegeEscalation: false
allowPrivilegedContainer: false
allowedCapabilities: []
defaultAddCapabilities: []
fsGroup:
  type: MustRunAs
  ranges:
    - min: 1000
      max: 65535
readOnlyRootFilesystem: false
requiredDropCapabilities:
  - ALL
runAsUser:
  type: MustRunAsRange
  uidRangeMin: 1000
  uidRangeMax: 65535
seLinuxContext:
  type: MustRunAs
supplementalGroups:
  type: RunAsAny
volumes:
  - configMap
  - downwardAPI
  - emptyDir
  - persistentVolumeClaim
  - projected
  - secret

1. Appliquez la SCC :
   oc apply -f wandb-scc.yaml
   
2. Associez la SCC aux comptes de service W&B :
   oc adm policy add-scc-to-user wandb-scc -z wandb-app -n wandb
   oc adm policy add-scc-to-user wandb-scc -z wandb-console -n wandb
   

​

Routes OpenShift

spec:
  values:
    ingress:
      enabled: false
    
    route:
      enabled: true
      host: wandb.apps.openshift.yourdomain.com
      tls:
        enabled: true
        termination: edge
        insecureEdgeTerminationPolicy: Redirect

​

Configuration de la récupération d’images pour OpenShift

1. Créez un secret de récupération d’image (image pull secret) :
   kubectl create secret docker-registry wandb-registry-secret \
     --docker-server=registry.yourdomain.com \
     --docker-username=[USERNAME] \
     --docker-password=[PASSWORD] \
     --namespace=wandb
   
2. Référencez le secret dans votre ressource personnalisée (Custom Resource) :
   spec:
     values:
       imagePullSecrets:
         - name: wandb-registry-secret
   

​

Exemple complet pour OpenShift

apiVersion: apps.wandb.com/v1
kind: WeightsAndBiases
metadata:
  name: wandb
  namespace: wandb

spec:
  chart:
    url: https://charts.yourdomain.com
    name: operator-wandb
    version: 0.18.0

  values:
    global:
      host: https://wandb.apps.openshift.yourdomain.com
      license: [YOUR-LICENSE]
      
      bucket:
        accessKey: [YOUR-ACCESS-KEY]
        secretKey: [YOUR-SECRET-KEY]
        name: s3.yourdomain.com:9000
        path: wandb
        provider: s3
        region: us-east-1
      
      mysql:
        database: wandb
        host: mysql.yourdomain.com
        password: [YOUR-MYSQL-PASSWORD]
        port: 3306
        user: wandb
      
      redis:
        host: redis.yourdomain.com
        port: 6379
        password: [YOUR-REDIS-PASSWORD]

    # Spécifique à OpenShift : utiliser des Routes au lieu d’un Ingress
    ingress:
      enabled: false
    
    route:
      enabled: true
      host: wandb.apps.openshift.yourdomain.com
      tls:
        enabled: true
        termination: edge

    # Secret de récupération d’image pour le registre interne
    imagePullSecrets:
      - name: wandb-registry-secret

    # Contextes de sécurité pour la SCC restricted d’OpenShift
    app:
      image:
        repository: registry.yourdomain.com/wandb/local
        tag: 0.59.2
      podSecurityContext:
        fsGroup: 1000
        runAsUser: 1000
        runAsNonRoot: true
      securityContext:
        allowPrivilegeEscalation: false
        capabilities:
          drop:
            - ALL
        runAsNonRoot: true
        seccompProfile:
          type: RuntimeDefault

    console:
      image:
        repository: registry.yourdomain.com/wandb/console
        tag: 2.12.2
      podSecurityContext:
        fsGroup: 1000
        runAsUser: 1000
        runAsNonRoot: true
      securityContext:
        allowPrivilegeEscalation: false
        capabilities:
          drop:
            - ALL
        runAsNonRoot: true
        seccompProfile:
          type: RuntimeDefault

    # Répéter les contextes de sécurité pour : api, executor, glue, parquet, weave
    # (exemple abrégé pour plus de clarté)

​

Vérifier votre installation

1. Installez la CLI W&B :
   pip install wandb
   
2. Connectez-vous à W&B :
   wandb login --host=https://YOUR_DNS_DOMAIN
   
   Par exemple :
   wandb login --host=https://wandb.company-name.com
   
3. Vérifiez l’installation :
   wandb verify
   

Default host selected:  https://wandb.company-name.com
Find detailed logs for this test at: /var/folders/pn/b3g3gnc11_sbsykqkm3tx5rh0000gp/T/tmpdtdjbxua/wandb
Checking if logged in...................................................✅
Checking signed URL upload..............................................✅
Checking ability to send large payloads through proxy...................✅
Checking requests to base url...........................................✅
Checking requests made over signed URLs.................................✅
Checking CORs configuration of the bucket...............................✅
Checking wandb package version is up to date............................✅
Checking logged metrics, saving and downloading a file..................✅
Checking artifact save and download workflows...........................✅

​

Vérifications supplémentaires pour les environnements isolés du réseau

1. Récupération d’image : vérifiez que tous les pods ont bien récupéré leurs images depuis votre registre interne :
   kubectl get pods -n wandb -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.status.phase}{"\t"}{.status.containerStatuses[*].image}{"\n"}{end}'
   
   Toutes les images doivent pointer vers votre registre interne et tous les pods doivent être à l’état Running.
2. Connectivité externe : vérifiez que W&B ne tente pas d’établir de connexions externes (ce qui ne doit pas se produire en mode isolé du réseau) :
   kubectl logs -n wandb deployment/wandb-app --tail=100 | grep -i "connection"
   
3. Validation de la licence : accédez à la console W&B et vérifiez que votre licence est active.

​

Dépannage

​

Erreurs de récupération d’image

• Assurez-vous que les images existent bien dans votre registre interne.
• Vérifiez que le secret de récupération d’image est correctement configuré.
• Contrôlez la connectivité réseau entre les nœuds Kubernetes et le registre.
• Vérifiez les identifiants d’authentification du registre.

kubectl run test-pull --image=registry.yourdomain.com/wandb/local:0.59.2 --namespace=wandb
kubectl logs test-pull -n wandb
kubectl delete pod test-pull -n wandb

​

Erreurs SCC OpenShift

# Vérifier quelle SCC est utilisée
oc get pod [POD-NAME] -n wandb -o yaml | grep scc

# Vérifier les autorisations du compte de service
oc describe scc wandb-scc
oc get rolebinding -n wandb

​

Chart Helm introuvable

• Vérifiez l’URL du dépôt de charts dans la Ressource personnalisée.
• Assurez-vous que le pod de l’opérateur peut accéder à votre dépôt Helm interne.
• Vérifiez que le chart existe bien dans votre dépôt :
  helm search repo local-repo/operator-wandb
  

​

Questions fréquentes

​

Puis-je utiliser une autre classe d’ingress ?

spec:
  values:
    ingress:
      class: your-ingress-class

​

Comment puis-je gérer des bundles de certificats contenant plusieurs certificats ?

spec:
  values:
    customCACerts:
      cert1.crt: |
        -----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
      cert2.crt: |
        -----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----

​

Comment puis-je empêcher les mises à jour automatiques ?

• Définissez airgapped: true dans l’installation de l’opérateur (cela désactive la vérification automatique des mises à jour).
• Gérez les mises à jour de version en modifiant manuellement spec.chart.version dans votre ressource personnalisée.
• Vous pouvez également désactiver les mises à jour automatiques depuis la System Console de W&B.

​

Le déploiement fonctionne-t-il sans connexion aux dépôts publics ?

​

Comment puis-je mettre à jour W&B dans un environnement isolé du réseau ?

1. Récupérez (pull) les nouvelles images de conteneur sur un système connecté à Internet.
2. Transférez les images vers votre registre isolé du réseau.
3. Téléversez les nouveaux charts Helm dans votre dépôt interne.
4. Mettez à jour spec.chart.version et les tags d’image dans votre ressource personnalisée.
5. Appliquez la ressource personnalisée mise à jour. L’opérateur effectue une mise à jour progressive (rolling update) des composants W&B.

​

Étapes suivantes

• Configurer l’authentification des utilisateurs : configurez le SSO ou d’autres méthodes d’authentification.
• Configurer la surveillance : mettez en place la surveillance de votre instance W&B et de votre infrastructure.
• Planifier les mises à jour : consultez le processus de mise à niveau du serveur et définissez un rythme de mise à jour.
• Configurer les sauvegardes : mettez en place des procédures de sauvegarde pour votre base de données MySQL.
• Documenter votre processus : rédigez des runbooks décrivant vos procédures de mise à jour propres à votre environnement isolé du réseau.

​

Obtenir de l’aide

• Consultez l’architecture de référence pour obtenir des recommandations sur l’infrastructure.
• Reportez-vous au guide de l’opérateur pour en savoir plus sur la configuration.
• Contactez l’assistance W&B ou l’ingénieur d’assistance W&B qui vous a été attribué.
• Pour les problèmes propres à OpenShift, consultez la documentation Red Hat OpenShift.