Déployer sur Kubernetes isolé du réseau

​

Introduction

• Les installations gouvernementales sécurisées.
• Les établissements financiers soumis à une isolation réseau stricte.
• Les organisations de santé soumises à des exigences de conformité.
• Les environnements de systèmes de contrôle industriels (ICS).
• Les centres de recherche disposant de réseaux classifiés.

​

Prérequis

​

Versions requises

​

Prérequis SSL/TLS

​

Prérequis matériels

​

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 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é pour stocker des données non structurées à grande échelle.
• Azure Blob Storage : service de stockage d’objets 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 compatible S3 de niveau entreprise, comme MinIO Enterprise (AIStor), NetApp StorageGRID ou d’autres solutions d’entreprise.

​

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

• Registre interne de conteneurs : un accès à un registre privé de conteneurs tel que Harbor, JFrog Artifactory ou Nexus, contenant toutes les images W&B requises.
• Dépôt Helm interne : un accès à un dépôt privé de chart Helm contenant les charts Helm W&B.
• Capacité 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), voir la section License de la page Requirements, ou contactez votre équipe commerciale W&B.

​

Préparez votre environnement isolé du réseau

​

Étape 1 : Configurer le registre de conteneurs interne

​

Conteneurs des composants W&B essentiels

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

​

Conteneurs de dépendances

• docker.io/bitnamilegacy/redis: Requis pour le déploiement local de Redis pendant les phases de test et de développement. Pour les exigences Redis en Production, voir la section Redis dans les prérequis.
• docker.io/otel/opentelemetry-collector-contrib: Agent OpenTelemetry pour collecter les métriques et les journaux.
• quay.io/prometheus/prometheus: Prometheus pour la collecte de métriques.
• quay.io/prometheus-operator/prometheus-config-reloader: Dépendance 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. Inspectez les fichiers values.yaml pour identifier toutes les images de conteneur et leurs versions :
   # Extraire les références d'image du chart operator
   helm show values charts/operator | grep -E "repository:|tag:" | grep -v "^#"
   
   # Extraire les références d'image du chart platform
   helm show values charts/operator-wandb | grep -E "repository:|tag:" | grep -v "^#"
   
   Vous pouvez également utiliser cette commande pour extraire uniquement les noms des 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 ressemblera à ceci :
   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 les tags de version spécifiques à chaque image, utilisez la première commande précédente (grep -E "repository:|tag:"), qui affiche à la fois les noms des dépôts et les tags de version correspondants.

​

Transférer des images vers un registre isolé du réseau

1. Sur un système connecté à Internet, téléchargez et enregistrez toutes les images requises.
   Remplacez les numéros de version dans les exemples suivants par les versions réelles obtenues lors de l’inspection de votre chart Helm à l’étape précédente. Les versions indiquées ici sont données à titre d’exemple et deviennent obsolètes au fil du temps.
   Utilisez des variables shell pour gérer les versions de manière cohérente :
   # Définir les variables de version (mettez-les à jour selon les versions de votre chart Helm)
   CONTROLLER_VERSION="1.13.3"
   APP_VERSION="0.59.2"
   CONSOLE_VERSION="2.12.2"
   
   # Télécharger 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}
   # ... télécharger 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 à l’aide de la méthode approuvée, par exemple une clé USB ou un transfert de fichiers sécurisé.
3. Dans votre environnement isolé du réseau, chargez les images et poussez-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
   
   # Pousser 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}
   # ... pousser toutes les autres images
   

​

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

• chart de l’opérateur W&B
• chart de la plateforme W&B

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 chart .tgz vers votre environnement isolé du réseau et téléversez-les dans votre dépôt Helm interne conformément aux procédures de votre dépôt. Le chart operator déploie l’opérateur Kubernetes W&B (Controller Manager). Le chart operator-wandb déploie la plateforme W&B à l’aide 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 utiliser 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 réelles que vous avez transférées vers votre registre interne à l’étape 1. La version indiquée ici (1.13.3) est un exemple et devient obsolète au fil du temps.
2. Installez l’opérateur et la définition de ressource personnalisée (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
   
   Vous devriez voir le pod de l’opérateur dans 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 toutes les images de composants pour utiliser 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 plateforme W&B

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 :
   # Surveiller 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é d’OpenShift

​

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

spec:
  values:
    # Configurer les contextes de sécurité pour 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

    # Répéter 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 le SCC :
   oc apply -f wandb-scc.yaml
   
2. Associez le SCC aux comptes de service de 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 d’OpenShift

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

​

Configuration de récupération d’image pour OpenShift

1. Créez un secret de récupération d’image :
   kubectl create secret docker-registry wandb-registry-secret \
     --docker-server=registry.yourdomain.com \
     --docker-username=[USERNAME] \
     --docker-password=[PASSWORD] \
     --namespace=wandb
   
2. Ajoutez une référence au secret dans votre Ressource personnalisée :
   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 plutôt que l'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 le 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
    # (abrégé par souci de clarté)

​

Vérifiez votre installation

1. Installez le W&B CLI :
   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 un environnement isolé du réseau

1. Récupération d’image : assurez-vous que tous les pods ont bien récupéré les 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 dans l’état Running.
2. Connectivité externe : vérifiez que W&B ne tente pas d’établir de connexions externes (cela ne devrait pas arriver 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

• Vérifiez que les images sont présentes dans votre registre interne.
• Vérifiez que le secret de récupération d’image est correctement configuré.
• Vérifiez 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 d’OpenShift

# Vérifier quel SCC est utilisé
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 Helm dans la Ressource personnalisée.
• Vérifiez que le pod de l’opérateur peut accéder à votre dépôt Helm interne.
• Vérifiez que le chart existe dans votre dépôt :
  helm search repo local-repo/operator-wandb
  

​

Foire aux questions

​

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 les vérifications automatiques de mise à jour).
• Gérez les mises à jour de version en mettant à jour manuellement spec.chart.version dans votre Ressource personnalisée.
• Si nécessaire, désactivez les mises à jour automatiques depuis la console système de W&B.

​

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

​

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

1. Téléchargez 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 des composants W&B.

​

Prochaines étapes

• Configurer l’authentification des utilisateurs : Configurez SSO ou d’autres méthodes d’authentification.
• Mettre en place la supervision : Configurez la supervision de votre instance W&B et de votre infrastructure.
• Planifier les mises à jour : Consultez le processus de mise à niveau du serveur et définissez une cadence de mise à jour.
• Configurer les sauvegardes : Mettez en place des procédures de sauvegarde pour votre base de données MySQL.
• Documenter votre processus : Créez des runbooks pour vos procédures spécifiques de mise à jour en environnement isolé.

​

Obtenir de l’aide

• Consultez l’architecture de référence pour obtenir des conseils sur l’infrastructure.
• Consultez le guide de l’opérateur pour plus de détails sur la configuration.
• Contactez l’assistance W&B ou votre ingénieur d’assistance W&B dédié.
• Pour les problèmes spécifiques à OpenShift, consultez la documentation Red Hat OpenShift.