L’opérateur Kubernetes W&B est la méthode recommandée pour déployer W&B Server sur Kubernetes (dans le cloud ou sur site). Pour un aperçu de l’opérateur, savoir pourquoi W&B l’utilise et comprendre le fonctionnement de la hiérarchie de configuration, voir Autogéré.
Avant de déployer W&B avec l’opérateur Kubernetes, assurez-vous que votre infrastructure répond à toutes les exigences :
- Vérifier les exigences de l’infrastructure : Voir la page des exigences d’infrastructure pour l’environnement Autogéré pour plus de détails sur :
- Exigences relatives aux versions logicielles (Kubernetes, MySQL, Redis, Helm)
- Exigences matérielles (architecture CPU, recommandations de dimensionnement)
- Configuration du cluster Kubernetes
- Exigences relatives au réseau, à SSL/TLS et au DNS
- Obtenir une licence W&B Server : Voir la section License sur la page des exigences.
- Préparer les services externes : Configurer MySQL, Redis et le stockage d’objets avant le déploiement.
Pour plus d’informations, voir la page de l’architecture de référence.
W&B nécessite une base de données MySQL externe.
Pour la Production, W&B recommande fortement d’utiliser des services de base de données gérés :
Les services de base de données gérés offrent des sauvegardes automatisées, de la supervision, une haute disponibilité et l’application des correctifs, tout en réduisant la charge opérationnelle.
Voir l’architecture de référence pour connaître l’ensemble des exigences MySQL, y compris les recommandations de dimensionnement et les paramètres de configuration. Pour le SQL de création de la base de données, consultez le guide bare-metal. Pour toute question sur la configuration de la base de données de votre déploiement, contactez l’assistance ou votre AISE.
Pour des instructions complètes sur la configuration de MySQL, y compris les paramètres de configuration et la création de la base de données, voir la section MySQL de la page des exigences.
W&B dépend d’un déploiement Redis 7.x à nœud unique, utilisé par les composants de W&B pour mettre les jobs en file d’attente et mettre les données en cache. Pour plus de commodité lors des tests et du développement de preuves de faisabilité, W&B Self-Managed inclut un déploiement Redis local qui n’est pas adapté aux déploiements de production.
Pour les déploiements de production, W&B peut se connecter à une instance Redis dans les environnements suivants :
Voir la section de configuration de Redis externe pour savoir comment configurer une instance Redis externe dans les valeurs Helm.
W&B requiert un stockage d’objets prenant en charge les URL pré-signées et CORS.
Fournisseurs de stockage recommandés :
- Amazon S3 : service de stockage d’objets offrant une évolutivité, une disponibilité des données, une sécurité et des performances de premier plan.
- Google Cloud Storage : service géré permettant de stocker des données non structurées à grande échelle.
- Azure Blob Storage : solution de stockage d’objets cloud pour stocker de grandes quantités de données non structurées.
- CoreWeave AI Object Storage : service de stockage d’objets hautes performances, compatible S3, optimisé pour les charges de travail d’IA.
- Stockage compatible S3 pour les entreprises : MinIO Enterprise (AIStor), NetApp StorageGRID ou d’autres solutions de niveau entreprise
MinIO Open Source est en mode de maintenance, sans développement actif ni binaires précompilés. Pour les déploiements de production, W&B recommande d’utiliser des services de stockage d’objets gérés ou des solutions compatibles S3 pour les entreprises, telles que MinIO Enterprise (AIStor). Provisionnez votre bucket de stockage
- Amazon S3 (y compris les politiques IAM et les politiques de bucket)
- Google Cloud Storage (y compris les notifications PubSub)
- Azure Blob Storage (y compris les identités gérées)
- CoreWeave AI Object Storage
- stockage compatible S3 (MinIO Enterprise, NetApp StorageGRID et d’autres solutions d’entreprise)
Voir la section de configuration du stockage d’objets pour plus de détails sur sa configuration dans les valeurs Helm.
clusters Kubernetes OpenShift
W&B recommande d’utiliser le chart Helm officiel de W&B pour l’installation.
Exécutez le conteneur avec un utilisateur non privilégié
$UID de 999. Spécifiez un $UID >= 100000 et un $GID de 0 si votre orchestrateur exige que le conteneur s’exécute sous un utilisateur non root.
W&B doit démarrer avec le groupe root ($GID=0) pour que les autorisations du système de fichiers fonctionnent correctement.
api:
install: true
image:
repository: wandb/megabinary
tag: 0.74.1 # Remplacez par votre version actuelle
pod:
securityContext:
fsGroup: 10001
fsGroupChangePolicy: Always
runAsGroup: 0
runAsNonRoot: true
runAsUser: 10001
seccompProfile:
type: RuntimeDefault
container:
securityContext:
allowPrivilegeEscalation: false
capabilities:
drop:
- ALL
privileged: false
readOnlyRootFilesystem: false
app ou console. Pour plus de détails, voir Contexte de sécurité personnalisé.
Déployer l’application W&B Server
L’opérateur Kubernetes W&B avec Helm est la méthode d’installation recommandée pour tous les déploiements W&B Autogéré, y compris dans les environnements cloud, sur site et isolé du réseau.
W&B fournit un chart Helm pour déployer l’opérateur Kubernetes W&B sur un cluster Kubernetes. Cette approche vous permet de déployer W&B Server avec la CLI Helm ou un outil de déploiement continu comme ArgoCD.Pour les considérations spécifiques au déploiement, voir Considérations spécifiques à l’environnement et Déployer avec Terraform sur un cloud public. Pour les environnements déconnectés, voir Déployer sur Kubernetes en environnement isolé.Suivez ces étapes pour installer l’opérateur Kubernetes W&B avec la CLI Helm :
-
Ajoutez le dépôt Helm W&B. Le chart Helm W&B est disponible dans le dépôt Helm W&B :
helm repo add wandb https://charts.wandb.ai
helm repo update
-
Installez l’opérateur sur un cluster Kubernetes :
helm upgrade --install operator wandb/operator -n wandb-cr --create-namespace
-
Configurez la ressource personnalisée de l’opérateur W&B pour déclencher l’installation de W&B Server. Créez un fichier nommé
operator.yaml avec votre configuration de déploiement W&B. Référez-vous à la Référence de configuration pour connaître toutes les options disponibles.
Voici une configuration minimale :
apiVersion: apps.wandb.com/v1
kind: WeightsAndBiases
metadata:
labels:
app.kubernetes.io/name: weightsandbiases
app.kubernetes.io/instance: wandb
name: wandb
namespace: default
spec:
values:
global:
host: https://<HOST_URI>
license: eyJhbGnUzaH...j9ZieKQ2x5GGfw
bucket:
<details depend on the provider>
mysql:
<redacted>
ingress:
annotations:
<redacted>
-
Lancez l’opérateur avec votre configuration personnalisée afin qu’il puisse installer, configurer et gérer l’application W&B Server :
kubectl apply -f operator.yaml
-
Pour vérifier l’installation via l’interface utilisateur web, créez le premier compte administrateur, puis suivez les étapes de vérification décrites dans Vérifiez l’installation.
Déployez W&B avec Terraform pour des déploiements en infrastructure as code. Choisissez entre :
- Module Terraform Helm : déploie l’opérateur sur une infrastructure Kubernetes existante
- Modules Terraform Cloud : déploiement complet de l’infrastructure et de l’application pour AWS, Google Cloud et Azure
Pour les considérations propres à chaque déploiement, voir Considérations propres à l’environnement et Déployer avec Terraform sur le cloud public. Pour les environnements déconnectés, voir Déployer sur Kubernetes en environnement isolé.Cette méthode permet de réaliser des déploiements personnalisés adaptés à des exigences spécifiques, en s’appuyant sur l’approche d’infrastructure as code de Terraform pour garantir la cohérence et la reproductibilité. Le module Terraform officiel de W&B basé sur Helm est disponible ici.Utilisez le code suivant comme point de départ. Il inclut toutes les options de configuration nécessaires pour un déploiement de niveau production :module "wandb" {
source = "wandb/wandb/helm"
spec = {
values = {
global = {
host = "https://<HOST_URI>"
license = "eyJhbGnUzaH...j9ZieKQ2x5GGfw"
bucket = {
<details depend on the provider>
}
mysql = {
<redacted>
}
}
ingress = {
annotations = {
"a" = "b"
"x" = "y"
}
}
}
}
}
Cette étape suppose que le premier compte administrateur a été créé depuis le navigateur.
- Installez le W&B CLI :
- Connectez-vous à W&B :
wandb login --host=https://YOUR_DNS_DOMAIN
wandb login --host=https://wandb.company-name.com
- Vérifiez l’installation :
Une installation réussie et un déploiement W&B pleinement opérationnel affichent la sortie suivante :
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...........................✅
Considérations spécifiques à l’environnement
Configuration de l’équilibreur de charge
- Équilibreur de charge externe : configurez un équilibreur de charge matériel ou logiciel existant (F5, HAProxy, etc.)
- Nginx Ingress Controller : déployez nginx-ingress-controller avec NodePort ou le réseau hôte
- MetalLB : pour les clusters Kubernetes bare metal, MetalLB fournit des services d’équilibreur de charge
Pour des exemples détaillés de configuration de l’équilibreur de charge, voir la section réseau de l’architecture de référence.
Assurez-vous que votre cluster Kubernetes dispose d’une StorageClass configurée pour les volumes persistants. Les composants W&B peuvent nécessiter un stockage persistant pour la mise en cache et les données temporaires.
Options courantes de stockage sur site :
- Classes de stockage basées sur NFS
- Stockage Ceph/Rook
- Volumes persistants locaux
- Solutions de stockage d’entreprise (NetApp, Pure Storage, etc.)
Gestion du DNS et des certificats
- Configurez les enregistrements DNS internes pour qu’ils pointent vers votre nom d’hôte W&B
- Générez des certificats SSL/TLS auprès de votre autorité de certification (CA) interne
- Si vous utilisez des certificats auto-signés, configurez l’opérateur pour qu’il fasse confiance à votre certificat d’autorité de certification (CA)
Voir les exigences SSL/TLS pour plus de détails sur la configuration des certificats.
W&B prend entièrement en charge les déploiements sur des clusters Kubernetes OpenShift. Les déploiements OpenShift nécessitent des configurations supplémentaires du contexte de sécurité en raison des politiques de sécurité plus strictes d’OpenShift.
Pour en savoir plus sur la configuration spécifique à OpenShift, voir clusters Kubernetes OpenShift ci-dessus. Pour des exemples complets de déploiement OpenShift dans des environnements isolés du réseau, voir Déployer sur Kubernetes isolé du réseau.
Stockage d’objets pour les environnements sur site et compatibles S3
bucket:
kmsKey: <kms key arn> # Clé KMS facultative pour le chiffrement
name: <bucket name> # Exemple : wandb
path: "" # Laisser comme chaîne vide
provider: s3
region: <region> # Exemple : us-east-1
bucket:
kmsKey: null
name: <s3 endpoint> # Exemple : s3.example.com:9000
path: <bucket name> # Exemple : wandb
provider: s3
region: <region> # Exemple : us-east-1
?tls=true au chemin du bucket :
bucket:
path: "wandb?tls=true"
Le certificat doit être approuvé. Les certificats autosignés nécessitent une configuration supplémentaire. Voir les exigences SSL/TLS pour en savoir plus.
- Capacité de stockage et performances : Surveillez attentivement la capacité du disque. Une utilisation moyenne de W&B représente de quelques dizaines à quelques centaines de gigaoctets. Une utilisation intensive peut entraîner des pétaoctets de consommation de stockage.
- Tolérance aux pannes : Au minimum, utilisez des baies RAID pour les disques physiques. Pour le stockage compatible S3, utilisez des configurations distribuées ou hautement disponibles.
- Disponibilité : Mettez en place une supervision afin de garantir que le stockage reste disponible.
Considérations relatives à MinIO
MinIO Open Source est en mode maintenance et ne fait plus l’objet de développement actif. Les binaires précompilés ne sont plus fournis et seuls les correctifs de sécurité critiques sont examinés au cas par cas. Pour les déploiements de production, W&B recommande d’utiliser des services gérés de stockage d’objets ou MinIO Enterprise (AIStor). mc config host add local http://$MINIO_HOST:$MINIO_PORT "$MINIO_ACCESS_KEY" "$MINIO_SECRET_KEY" --api s3v4
mc mb --region=us-east-1 local/wandb-files
W&B recommande des options de déploiement entièrement gérées, comme W&B Multi-tenant Cloud ou W&B Dedicated Cloud. Les services entièrement gérés de W&B sont simples à utiliser et sécurisés, avec peu ou pas de configuration requise. W&B recommande d’utiliser le W&B Server AWS Terraform Module pour déployer la plateforme sur AWS.Le module Terraform déploie les composants obligatoires suivants :
- Équilibreur de charge
- AWS Identity & Access Management (IAM)
- AWS Key Management System (KMS)
- Amazon Aurora MySQL
- Amazon VPC
- Amazon S3
- Amazon Route53
- Amazon Certificate Manager (ACM)
- Amazon Elastic Load Balancing (ALB)
- Amazon Secrets Manager
Les composants facultatifs incluent :
- ElastiCache pour Redis
- SQS
Permissions requises
Le compte qui exécute Terraform doit pouvoir créer tous les composants décrits ci-dessus et disposer des autorisations nécessaires pour créer des IAM Policies et des IAM Roles, ainsi qu’attribuer des rôles aux ressources.Étapes générales
Les étapes de cette section sont communes à toutes les options de déploiement.
-
Préparez l’environnement de développement.
- Installez Terraform
- W&B recommande de créer un dépôt Git pour le suivi des versions.
-
Créez le fichier
terraform.tfvars.
Le contenu du fichier tvfars peut être personnalisé selon le type d’installation, mais la configuration minimale recommandée ressemble à l’exemple ci-dessous.
namespace = "wandb"
license = "xxxxxxxxxxyyyyyyyyyyyzzzzzzz"
subdomain = "wandb-aws"
domain_name = "wandb.ml"
zone_id = "xxxxxxxxxxxxxxxx"
allowed_inbound_cidr = ["0.0.0.0/0"]
allowed_inbound_ipv6_cidr = ["::/0"]
eks_cluster_version = "1.29"
tvfars avant de déployer, car la variable namespace est une chaîne de caractères utilisée comme préfixe pour toutes les ressources créées par Terraform.
La combinaison de subdomain et domain forme le FQDN de votre instance W&B. Dans l’exemple ci-dessus, le FQDN W&B sera wandb-aws.wandb.ml, ainsi que le zone_id DNS dans lequel l’enregistrement FQDN sera créé.
Les paramètres allowed_inbound_cidr et allowed_inbound_ipv6_cidr doivent également être définis. Dans le module, il s’agit d’une entrée obligatoire. L’exemple suivant autorise l’accès à l’installation W&B depuis n’importe quelle source.
-
Créez le fichier
versions.tf
Ce fichier contiendra les versions requises de Terraform et du fournisseur Terraform pour déployer W&B sur AWS :
provider "aws" {
region = "eu-central-1"
default_tags {
tags = {
GithubRepo = "terraform-aws-wandb"
GithubOrg = "wandb"
Enviroment = "Example"
Example = "PublicDnsExternal"
}
}
}
-
Créez le fichier
variables.tf
Pour chaque option configurée dans terraform.tfvars, Terraform nécessite une déclaration de variable correspondante.
variable "namespace" {
type = string
description = "Préfixe de nom utilisé pour les ressources"
}
variable "domain_name" {
type = string
description = "Nom de domaine utilisé pour accéder à l'instance."
}
variable "subdomain" {
type = string
default = null
description = "Sous-domaine pour accéder à l'UI Weights & Biases."
}
variable "license" {
type = string
}
variable "zone_id" {
type = string
description = "Domaine sur lequel créer le sous-domaine Weights & Biases."
}
variable "allowed_inbound_cidr" {
description = "CIDRs autorisés à accéder à wandb-server."
nullable = false
type = list(string)
}
variable "allowed_inbound_ipv6_cidr" {
description = "CIDRs autorisés à accéder à wandb-server."
nullable = false
type = list(string)
}
variable "eks_cluster_version" {
description = "Version Kubernetes du cluster EKS"
nullable = false
type = string
}
Déploiement recommandé
Il s’agit de la configuration de déploiement la plus simple, qui crée tous les composants obligatoires et installe la dernière version de W&B dans le cluster Kubernetes.
-
Créez le fichier
main.tf
Dans le même répertoire que celui où vous avez créé les fichiers dans les étapes General, créez un fichier main.tf avec le contenu suivant :
module "wandb_infra" {
source = "wandb/wandb/aws"
version = "~>7.0"
namespace = var.namespace
domain_name = var.domain_name
license = var.license
subdomain = var.subdomain
zone_id = var.zone_id
allowed_inbound_cidr = var.allowed_inbound_cidr
allowed_inbound_ipv6_cidr = var.allowed_inbound_ipv6_cidr
public_access = true
external_dns = true
kubernetes_public_access = true
kubernetes_public_access_cidrs = ["0.0.0.0/0"]
eks_cluster_version = var.eks_cluster_version
}
data "aws_eks_cluster" "eks_cluster_id" {
name = module.wandb_infra.cluster_name
}
data "aws_eks_cluster_auth" "eks_cluster_auth" {
name = module.wandb_infra.cluster_name
}
provider "kubernetes" {
host = data.aws_eks_cluster.eks_cluster_id.endpoint
cluster_ca_certificate = base64decode(data.aws_eks_cluster.eks_cluster_id.certificate_authority.0.data)
token = data.aws_eks_cluster_auth.eks_cluster_auth.token
}
provider "helm" {
kubernetes {
host = data.aws_eks_cluster.eks_cluster_id.endpoint
cluster_ca_certificate = base64decode(data.aws_eks_cluster.eks_cluster_id.certificate_authority.0.data)
token = data.aws_eks_cluster_auth.eks_cluster_auth.token
}
}
output "url" {
value = module.wandb_infra.url
}
output "bucket" {
value = module.wandb_infra.bucket_name
}
-
Déployer W&B
Pour déployer W&B, exécutez les commandes suivantes :
terraform init
terraform apply -var-file=terraform.tfvars
Activer Redis
Pour utiliser Redis afin de mettre en cache les requêtes SQL et accélérer la réponse de l’application lors du chargement des métriques, ajoutez l’option create_elasticache_subnet = true au fichier main.tf :module "wandb_infra" {
source = "wandb/wandb/aws"
version = "~>7.0"
namespace = var.namespace
domain_name = var.domain_name
subdomain = var.subdomain
zone_id = var.zone_id
create_elasticache_subnet = true
}
[...]
Activer le courtier de messages (file d’attente)
Pour activer un courtier de messages externe via SQS, ajoutez l’option use_internal_queue = false au fichier main.tf :Ceci est facultatif, car W&B inclut un broker intégré. Cette option n’apporte aucune amélioration des performances.
module "wandb_infra" {
source = "wandb/wandb/aws"
version = "~>7.0"
namespace = var.namespace
domain_name = var.domain_name
subdomain = var.subdomain
zone_id = var.zone_id
use_internal_queue = false
[...]
}
Ressources supplémentaires
W&B recommande d’utiliser le W&B Server Google Cloud Terraform Module pour déployer la plateforme sur Google Cloud.La documentation du module est complète et répertorie toutes les options disponibles.Avant de commencer, W&B vous recommande de choisir l’un des backends distants disponibles pour Terraform afin de stocker le fichier d’état. Le fichier d’état est la ressource indispensable pour déployer des mises à jour ou effectuer des modifications dans votre déploiement sans recréer tous les composants.Le module Terraform déploie les composants obligatoires suivants :
- VPC
- Cloud SQL for MySQL
- Bucket de stockage dans le cloud
- Google Kubernetes Engine
- Memorystore for Redis
- Clé de chiffrement KMS
- Équilibreur de charge
Les composants facultatifs incluent :
- Système de messagerie Pub/Sub
Autorisations préalables
Le compte qui exécutera Terraform doit disposer du rôle roles/owner dans le projet Google Cloud utilisé.Étapes générales
Les étapes de cette section sont communes à toutes les options de déploiement.
-
Préparez l’environnement de développement.
- Installez Terraform.
- W&B recommande de créer un dépôt Git avec le code qui sera utilisé, mais vous pouvez conserver vos fichiers en local.
- Créez un projet dans Google Cloud Console.
- Authentifiez-vous avec Google Cloud (veillez à installer gcloud au préalable) à l’aide de
gcloud auth application-default login.
-
Créez le fichier
terraform.tfvars.
Le contenu du fichier tvfars peut être personnalisé en fonction du type d’installation, mais la configuration minimale recommandée ressemble à l’exemple ci-dessous.
project_id = "wandb-project"
region = "europe-west2"
zone = "europe-west2-a"
namespace = "wandb"
license = "xxxxxxxxxxyyyyyyyyyyyzzzzzzz"
subdomain = "wandb-gcp"
domain_name = "wandb.ml"
namespace sera une chaîne de caractères qui servira de préfixe à toutes les ressources créées par Terraform.
La combinaison de subdomain et de domain formera le FQDN avec lequel W&B sera configuré. Dans l’exemple ci-dessus, le FQDN de W&B sera wandb-gcp.wandb.ml.
-
Créez le fichier
variables.tf.
Pour chaque option configurée dans terraform.tfvars, Terraform exige qu’une variable correspondante soit déclarée.
variable "project_id" {
type = string
description = "Project ID"
}
variable "region" {
type = string
description = "Google region"
}
variable "zone" {
type = string
description = "Google zone"
}
variable "namespace" {
type = string
description = "Namespace prefix used for resources"
}
variable "domain_name" {
type = string
description = "Domain name for accessing the Weights & Biases UI."
}
variable "subdomain" {
type = string
description = "Subdomain for access the Weights & Biases UI."
}
variable "license" {
type = string
description = "W&B License"
}
Déploiement recommandé
Il s’agit de la configuration de déploiement la plus simple, qui crée tous les composants obligatoires et installe la dernière version de W&B dans le cluster Kubernetes.
-
Créez le fichier
main.tf
Dans le même répertoire où vous avez créé les fichiers à l’étape « Étapes générales », créez un fichier main.tf avec le contenu suivant :
provider "google" {
project = var.project_id
region = var.region
zone = var.zone
}
provider "google-beta" {
project = var.project_id
region = var.region
zone = var.zone
}
data "google_client_config" "current" {}
provider "kubernetes" {
host = "https://${module.wandb.cluster_endpoint}"
cluster_ca_certificate = base64decode(module.wandb.cluster_ca_certificate)
token = data.google_client_config.current.access_token
}
provider "helm" {
kubernetes {
host = "https://${module.wandb.cluster_endpoint}"
cluster_ca_certificate = base64decode(module.wandb.cluster_ca_certificate)
token = data.google_client_config.current.access_token
}
}
# Démarrer tous les services requis
module "wandb" {
source = "wandb/wandb/google"
version = "~> 10.0"
namespace = var.namespace
license = var.license
domain_name = var.domain_name
subdomain = var.subdomain
}
# Mettez à jour votre DNS avec l'adresse IP provisionnée
output "url" {
value = module.wandb.url
}
output "address" {
value = module.wandb.address
}
output "bucket_name" {
value = module.wandb.bucket_name
}
-
Déployez W&B.
Pour déployer W&B, exécutez les commandes suivantes :
terraform init
terraform apply -var-file=terraform.tfvars
Activer Redis
Pour utiliser Redis afin de mettre en cache les requêtes SQL et accélérer la réponse de l’application lors du chargement des métriques, ajoutez l’option create_redis = true au fichier main.tf :[...]
module "wandb" {
source = "wandb/wandb/google"
version = "~> 10.0"
namespace = var.namespace
license = var.license
domain_name = var.domain_name
subdomain = var.subdomain
create_redis = true
}
[...]
Activer le courtier de messages (file d’attente)
Pour activer un courtier de messages externe via Pub/Sub, ajoutez l’option use_internal_queue = false au fichier main.tf :Cette option est facultative, car W&B inclut un broker intégré. Elle n’améliore pas les performances.
[...]
module "wandb" {
source = "wandb/wandb/google"
version = "~> 10.0"
namespace = var.namespace
license = var.license
domain_name = var.domain_name
subdomain = var.subdomain
use_internal_queue = false
}
[...]
Ressources supplémentaires
W&B recommande d’utiliser le W&B Server Azure Terraform Module pour déployer la plateforme sur Azure.La documentation du module est complète et répertorie toutes les options disponibles.Le module Terraform déploie les composants obligatoires suivants :
- Groupe de ressources Azure
- Azure Virtual Network (VPC)
- Azure MySQL Flexible Server
- Compte de stockage Azure & Blob Storage
- Azure Kubernetes Service
- Azure Application Gateway
Les composants facultatifs incluent :
- Azure Cache for Redis
- Azure Event Grid
Permissions requises
La façon la plus simple de configurer le fournisseur AzureRM est via Azure CLI, mais dans un contexte d’automatisation, l’utilisation d’Azure Service Principal peut également s’avérer utile.Quelle que soit la méthode d’authentification utilisée, le compte qui exécutera Terraform doit pouvoir créer tous les composants décrits ci-dessus.Étapes générales
Les étapes de cette section sont communes à toutes les options de déploiement.
-
Préparez l’environnement de développement.
- Installez Terraform
- W&B recommande de créer un dépôt Git contenant le code à utiliser, mais vous pouvez conserver vos fichiers en local.
-
Créez le fichier
terraform.tfvars.
Le contenu du fichier tvfars peut être personnalisé selon le type d’installation, mais la configuration minimale recommandée ressemblera à l’exemple ci-dessous.
namespace = "wandb"
wandb_license = "xxxxxxxxxxyyyyyyyyyyyzzzzzzz"
subdomain = "wandb-azure"
domain_name = "wandb.ml"
location = "westeurope"
namespace sera une chaîne de caractères qui servira de préfixe à toutes les ressources créées par Terraform.
La combinaison de subdomain et domain formera le FQDN avec lequel W&B sera configuré. Dans l’exemple ci-dessus, le FQDN de W&B sera wandb-azure.wandb.ml.
-
Créez le fichier
versions.tf
Ce fichier contiendra les versions de Terraform et du fournisseur Terraform requises pour déployer W&B sur Azure :
terraform {
required_version = "~> 1.3"
required_providers {
azurerm = {
source = "hashicorp/azurerm"
version = "~> 3.17"
}
}
}
-
Créez le fichier
variables.tf
Pour chaque option configurée dans terraform.tfvars, Terraform exige une déclaration de variable correspondante.
variable "namespace" {
type = string
description = "String used for prefix resources."
}
variable "location" {
type = string
description = "Azure Resource Group location"
}
variable "domain_name" {
type = string
description = "Domain for accessing the Weights & Biases UI."
}
variable "subdomain" {
type = string
default = null
description = "Subdomain for accessing the Weights & Biases UI. Default creates record at Route53 Route."
}
variable "license" {
type = string
description = "Your wandb/local license"
}
Déploiement recommandé
Il s’agit de la configuration de déploiement la plus simple, qui crée tous les composants obligatoires et installe la dernière version de W&B dans le cluster Kubernetes.
-
Créez le fichier
main.tf
Dans le même répertoire où vous avez créé les fichiers lors des étapes générales, créez un fichier main.tf avec le contenu suivant :
provider "azurerm" {
features {}
}
provider "kubernetes" {
host = module.wandb.cluster_host
cluster_ca_certificate = base64decode(module.wandb.cluster_ca_certificate)
client_key = base64decode(module.wandb.cluster_client_key)
client_certificate = base64decode(module.wandb.cluster_client_certificate)
}
provider "helm" {
kubernetes {
host = module.wandb.cluster_host
cluster_ca_certificate = base64decode(module.wandb.cluster_ca_certificate)
client_key = base64decode(module.wandb.cluster_client_key)
client_certificate = base64decode(module.wandb.cluster_client_certificate)
}
}
# Lancer tous les services requis
module "wandb" {
source = "wandb/wandb/azurerm"
version = "~> 1.2"
namespace = var.namespace
location = var.location
license = var.license
domain_name = var.domain_name
subdomain = var.subdomain
deletion_protection = false
tags = {
"Example" : "PublicDns"
}
}
output "address" {
value = module.wandb.address
}
output "url" {
value = module.wandb.url
}
-
Déployer W&B
Pour déployer W&B, exécutez les commandes suivantes :
terraform init
terraform apply -var-file=terraform.tfvars
Activer Redis
Pour utiliser Redis afin de mettre en cache les requêtes SQL et accélérer la réponse de l’application lors du chargement des métriques, ajoutez l’option create_redis = true au fichier main.tf :# Démarrer tous les services requis
module "wandb" {
source = "wandb/wandb/azurerm"
version = "~> 1.2"
namespace = var.namespace
location = var.location
license = var.license
domain_name = var.domain_name
subdomain = var.subdomain
create_redis = true
[...]
}
Activer le courtier de messages (file d’attente)
Pour activer un courtier de messages externe à l’aide d’Azure Event Grid, ajoutez l’option use_internal_queue = false au fichier main.tf :C’est facultatif, car W&B inclut un broker intégré. Cette option n’apporte aucun gain de performances.
# Démarrer tous les services requis
module "wandb" {
source = "wandb/wandb/azurerm"
version = "~> 1.2"
namespace = var.namespace
location = var.location
license = var.license
domain_name = var.domain_name
subdomain = var.subdomain
use_internal_queue = false
[...]
}
Ressources supplémentaires
Autres options de déploiement
Accéder à la console de gestion W&B
${HOST_URI}/console, par exemple https://wandb.company-name.com/console.
Vous pouvez vous connecter à la console de gestion de deux façons :
Option 1 (Recommandée)
Option 2
-
Ouvrez l’application W&B dans votre navigateur et connectez-vous. Connectez-vous à l’application W&B à l’adresse
${HOST_URI}/, par exemple https://wandb.company-name.com/
-
Accédez à la console. Cliquez sur l’icône dans le coin supérieur droit, puis sur Console système. Seuls les utilisateurs disposant des privilèges d’administrateur peuvent voir l’entrée Console système.
W&B recommande de suivre les étapes ci-dessous pour accéder à la console uniquement si l’option 1 ne fonctionne pas.
- Ouvrez l’application de console dans votre navigateur. Ouvrez l’URL décrite ci-dessus, qui vous redirige vers l’écran de connexion :
- Récupérez le mot de passe depuis le secret Kubernetes généré par l’installation :
kubectl get secret wandb-password -o jsonpath='{.data.password}' | base64 -d
- Connectez-vous à la console. Collez le mot de passe copié, puis cliquez sur Login.
Mettre à jour l’opérateur Kubernetes W&B
- La mise à jour de l’opérateur Kubernetes W&B ne met pas à jour l’application W&B Server.
- Voir les instructions ici si vous utilisez un chart Helm qui n’utilise pas l’opérateur Kubernetes W&B, avant de suivre les instructions ci-dessous pour mettre à jour l’opérateur W&B.
-
Commencez par mettre à jour le dépôt avec
helm repo update :
-
Ensuite, mettez à jour le chart Helm avec
helm upgrade :
helm upgrade operator wandb/operator -n wandb-cr --reuse-values
Mettre à jour l’application W&B Server
Migrer des instances Autogéré vers W&B Operator
W&B Operator est la méthode d’installation par défaut et recommandée pour W&B Server. Contactez Customer Support ou votre équipe W&B si vous avez des questions. Migrer vers le chart Helm basé sur un opérateur
-
Obtenez la configuration W&B actuelle. Si W&B a été déployé avec une version du chart Helm non basée sur un opérateur, exportez les valeurs comme ceci :
Si W&B a été déployé avec des manifests Kubernetes, exportez les valeurs comme ceci :
kubectl get deployment wandb -o yaml
-
Créez un fichier nommé
operator.yaml. Suivez le format décrit dans la Référence de configuration. Utilisez les valeurs de l’étape 1.
-
Réduisez le déploiement actuel à 0 pods. Cette étape arrête le déploiement actuel.
kubectl scale --replicas=0 deployment wandb
-
Mettez à jour le dépôt du chart Helm :
-
Installez le nouveau chart Helm :
helm upgrade --install operator wandb/operator -n wandb-cr --create-namespace
-
Configurez le nouveau chart Helm et déclenchez le déploiement de l’application W&B. Appliquez la nouvelle configuration.
kubectl apply -f operator.yaml
-
Vérifiez l’installation. Assurez-vous que tout fonctionne en suivant les étapes de Vérifiez l’installation.
-
Supprimez l’ancienne installation. Désinstallez l’ancien chart Helm ou supprimez les ressources créées à l’aide de manifests.
Suivez ces étapes pour migrer vers le chart Helm basé sur l’opérateur :
- Préparez la configuration Terraform. Remplacez dans votre configuration Terraform le code Terraform de l’ancien déploiement par celui décrit ici. Définissez les mêmes variables qu’auparavant. Ne modifiez pas le fichier .tfvars si vous en avez un.
- Exécutez Terraform. Exécutez terraform init, plan et apply
- Vérifiez l’installation. Assurez-vous que tout fonctionne en suivant les étapes de Vérifiez l’installation.
- Supprimez l’ancienne installation. Désinstallez l’ancien chart Helm ou supprimez les ressources créées à l’aide de manifest.
Référence de configuration pour W&B Server
apiVersion: apps.wandb.com/v1
kind: WeightsAndBiases
metadata:
labels:
app.kubernetes.io/name: weightsandbiases
app.kubernetes.io/instance: wandb
name: wandb
namespace: default
spec:
values:
global:
host: https://<HOST_URI>
license: eyJhbGnUzaH...j9ZieKQ2x5GGfw
bucket:
<details depend on the provider>
mysql:
<redacted>
ingress:
annotations:
<redacted>
apiVersion: apps.wandb.com/v1
kind: WeightsAndBiases
metadata:
labels:
app.kubernetes.io/name: weightsandbiases
app.kubernetes.io/instance: wandb
name: wandb
namespace: default
spec:
values:
global:
host: https://abc-wandb.sandbox-gcp.wandb.ml
bucket:
name: abc-wandb-moving-pipefish
provider: gcs
mysql:
database: wandb_local
host: 10.218.0.2
name: wandb_local
password: 8wtX6cJHizAZvYScjDzZcUarK4zZGjpV
port: 3306
user: wandb
redis:
host: redis.example.com
port: 6379
password: password
api:
enabled: true
glue:
enabled: true
executor:
enabled: true
license: eyJhbGnUzaHgyQjQyQWhEU3...ZieKQ2x5GGfw
ingress:
annotations:
ingress.gcp.kubernetes.io/pre-shared-cert: abc-wandb-cert-creative-puma
kubernetes.io/ingress.class: gce
kubernetes.io/ingress.global-static-ip-name: abc-wandb-operator-address
# Indiquez le FQDN avec le protocole
global:
# exemple de nom d'hôte, remplacez par le vôtre
host: https://wandb.example.com
Stockage d’objets (bucket)
global:
bucket:
provider: "s3"
name: ""
kmsKey: ""
region: ""
global:
bucket:
provider: "gcs"
name: ""
global:
bucket:
provider: "az"
name: ""
secretKey: ""
global:
bucket:
# Exemples de valeurs, remplacez par les vôtres
provider: s3
name: storage.example.com
kmsKey: null
path: wandb
region: default
accessKey: 5WOA500...P5DK7I
secretKey: HDKYe4Q...JAp1YyjysnX
kmsKey doit être null.
Pour faire référence à accessKey et secretKey depuis un secret :
global:
bucket:
# Exemples de valeurs, remplacez par les vôtres
provider: s3
name: storage.example.com
kmsKey: null
path: wandb
region: default
secret:
secretName: bucket-secret
accessKeyName: ACCESS_KEY
secretKeyName: SECRET_KEY
global:
mysql:
# Exemples de valeurs, remplacez par les vôtres
host: db.example.com
port: 3306
database: wandb_local
user: wandb
password: 8wtX6cJH...ZcUarK4zZGjpV
password d’un secret :
global:
mysql:
# Exemples de valeurs, remplacez par les vôtres
host: db.example.com
port: 3306
database: wandb_local
user: wandb
passwordSecret:
name: database-secret
passwordKey: MYSQL_WANDB_PASSWORD
global:
# Exemple de licence, remplacez par la vôtre
license: eyJhbGnUzaHgyQjQy...VFnPS_KETXg1hi
license à partir d’un secret :
global:
licenseSecret:
name: license-secret
key: CUSTOMER_WANDB_LICENSE
global:
# IMPORTANT : Ingress se trouve au même niveau dans le YAML que 'global' (pas un enfant)
ingress:
class: ""
kubectl create secret tls wandb-ingress-tls --key wandb-ingress-tls.key --cert wandb-ingress-tls.crt
global:
# IMPORTANT : Ingress est au même niveau que 'global' dans le YAML (pas un enfant)
ingress:
class: ""
annotations:
{}
# kubernetes.io/ingress.class: nginx
# kubernetes.io/tls-acme: "true"
tls:
- secretName: wandb-ingress-tls
hosts:
- <HOST_URI>
ingress:
annotations:
nginx.ingress.kubernetes.io/proxy-body-size: 0
Comptes de service Kubernetes personnalisés
app:
serviceAccount:
name: custom-service-account
create: true
parquet:
serviceAccount:
name: custom-service-account
create: true
global:
...
create: false :
app:
serviceAccount:
name: custom-service-account
create: false
parquet:
serviceAccount:
name: custom-service-account
create: false
global:
...
app:
serviceAccount:
name: custom-service-account
create: true
console:
serviceAccount:
name: custom-service-account
create: true
global:
...
app:
serviceAccount:
name: custom-service-account
create: false
console:
serviceAccount:
name: another-custom-service-account
create: true
global:
...
redis:
install: false
global:
redis:
host: ""
port: 6379
password: ""
parameters: {}
caCert: ""
password à partir d’un secret :
kubectl create secret generic redis-secret --from-literal=redis-password=supersecret
redis:
install: false
global:
redis:
host: redis.example
port: 9001
auth:
enabled: true
secret: redis-secret
key: redis-password
La prise en charge de la configuration LDAP dans le chart Helm actuel est limitée. Contactez l’équipe d’assistance de W&B ou votre AISE pour vous aider à configurer LDAP.
global.extraEnv :
global:
extraEnv:
LDAP_ADDRESS: ldaps://ldap.company.example.com
LDAP_BASE_DN: cn=accounts,dc=company,dc=example,dc=com
LDAP_USER_BASE_DN: cn=users,cn=accounts,dc=company,dc=example,dc=com
LDAP_GROUP_BASE_DN: cn=groups,cn=accounts,dc=company,dc=example,dc=com
LDAP_BIND_DN: uid=ldapbind,cn=sysaccounts,cn=etc,dc=company,dc=example,dc=com
LDAP_BIND_PW: ********************
LDAP_ATTRIBUTES: email=mail,name=cn
LDAP_TLS_ENABLE: "true"
LDAP_LOGIN: "true"
LDAP_USER_OBJECT_CLASS: user
LDAP_GROUP_OBJECT_CLASS: group
global:
auth:
sessionLengthHours: 720
oidc:
clientId: ""
secret: ""
# À inclure uniquement si votre IdP l'exige.
authMethod: ""
issuer: ""
authMethod est facultatif.
global:
email:
smtp:
host: ""
port: 587
user: ""
password: ""
Variables d’environnement
global:
extraEnv:
GLOBAL_ENV: "example"
Autorité de certification personnalisée
customCACerts est une liste qui peut contenir plusieurs certificats. Les autorités de certification spécifiées dans customCACerts s’appliquent uniquement à l’application W&B Server.
global:
customCACerts:
- |
-----BEGIN CERTIFICATE-----
MIIBnDCCAUKgAwIBAg.....................fucMwCgYIKoZIzj0EAwIwLDEQ
MA4GA1UEChMHSG9tZU.....................tZUxhYiBSb290IENBMB4XDTI0
MDQwMTA4MjgzMFoXDT.....................oNWYggsMo8O+0mWLYMAoGCCqG
SM49BAMCA0gAMEUCIQ.....................hwuJgyQRaqMI149div72V2QIg
P5GD+5I+02yEp58Cwxd5Bj2CvyQwTjTO4hiVl1Xd0M0=
-----END CERTIFICATE-----
- |
-----BEGIN CERTIFICATE-----
MIIBxTCCAWugAwIB.......................qaJcwCgYIKoZIzj0EAwIwLDEQ
MA4GA1UEChMHSG9t.......................tZUxhYiBSb290IENBMB4XDTI0
MDQwMTA4MjgzMVoX.......................UK+moK4nZYvpNpqfvz/7m5wKU
SAAwRQIhAIzXZMW4.......................E8UFqsCcILdXjAiA7iTluM0IU
aIgJYVqKxXt25blH/VyBRzvNhViesfkNUQ==
-----END CERTIFICATE-----
global:
caCertsConfigMap: custom-ca-certs
apiVersion: v1
kind: ConfigMap
metadata:
name: custom-ca-certs
data:
ca-cert1.crt: |
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
ca-cert2.crt: |
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
Si vous utilisez une ConfigMap, chaque clé de la ConfigMap doit se terminer par .crt (par exemple, my-cert.crt ou ca-cert1.crt). Cette convention de nommage est requise pour que update-ca-certificates puisse traiter et ajouter chaque certificat au magasin système des autorités de certification.
Contexte de sécurité personnalisé
pod:
securityContext:
runAsNonRoot: true
runAsUser: 1001
runAsGroup: 0
fsGroup: 1001
fsGroupChangePolicy: Always
seccompProfile:
type: RuntimeDefault
container:
securityContext:
capabilities:
drop:
- ALL
readOnlyRootFilesystem: false
allowPrivilegeEscalation: false
La seule valeur valide pour runAsGroup: est 0. Toute autre valeur constitue une erreur.
app à votre configuration :
global:
...
app:
pod:
securityContext:
runAsNonRoot: true
runAsUser: 1001
runAsGroup: 0
fsGroup: 1001
fsGroupChangePolicy: Always
seccompProfile:
type: RuntimeDefault
container:
securityContext:
capabilities:
drop:
- ALL
readOnlyRootFilesystem: false
allowPrivilegeEscalation: false
console, weave, weave-trace et parquet.
Référence de configuration pour l’opérateur W&B
wandb-controller-manager). L’opérateur reçoit sa configuration sous la forme d’un fichier YAML.
Par défaut, l’opérateur Kubernetes W&B n’a pas besoin de fichier de configuration. Créez un fichier de configuration si nécessaire. Par exemple, vous pouvez en avoir besoin pour spécifier des autorités de certification personnalisées, déployer dans un environnement isolé (air gap), etc.
Consultez la liste complète des personnalisations de la spécification dans le dépôt Helm.
Une autorité de certification personnalisée (customCACerts) correspond à une liste pouvant contenir plusieurs certificats. Une fois ajoutées, ces autorités de certification s’appliquent uniquement à l’opérateur Kubernetes W&B (wandb-controller-manager).
customCACerts:
- |
-----BEGIN CERTIFICATE-----
MIIBnDCCAUKgAwIBAg.....................fucMwCgYIKoZIzj0EAwIwLDEQ
MA4GA1UEChMHSG9tZU.....................tZUxhYiBSb290IENBMB4XDTI0
MDQwMTA4MjgzMFoXDT.....................oNWYggsMo8O+0mWLYMAoGCCqG
SM49BAMCA0gAMEUCIQ.....................hwuJgyQRaqMI149div72V2QIg
P5GD+5I+02yEp58Cwxd5Bj2CvyQwTjTO4hiVl1Xd0M0=
-----END CERTIFICATE-----
- |
-----BEGIN CERTIFICATE-----
MIIBxTCCAWugAwIB.......................qaJcwCgYIKoZIzj0EAwIwLDEQ
MA4GA1UEChMHSG9t.......................tZUxhYiBSb290IENBMB4XDTI0
MDQwMTA4MjgzMVoX.......................UK+moK4nZYvpNpqfvz/7m5wKU
SAAwRQIhAIzXZMW4.......................E8UFqsCcILdXjAiA7iTluM0IU
aIgJYVqKxXt25blH/VyBRzvNhViesfkNUQ==
-----END CERTIFICATE-----
caCertsConfigMap: custom-ca-certs
apiVersion: v1
kind: ConfigMap
metadata:
name: custom-ca-certs
data:
ca-cert1.crt: |
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
ca-cert2.crt: |
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
Chaque clé du ConfigMap doit se terminer par .crt (par exemple, my-cert.crt ou ca-cert1.crt). Cette convention de nommage est nécessaire pour que update-ca-certificates puisse interpréter et ajouter chaque certificat au magasin système d’autorités de certification.
Quel est l’objectif/le rôle de chaque pod ?
wandb-app: le cœur de W&B, y compris l’API GraphQL et l’application frontend. Il assure la majeure partie des fonctionnalités de notre plateforme.wandb-console: la console d’administration, accessible via /console.wandb-otel: l’agent OpenTelemetry, qui collecte les métriques et les journaux des ressources au niveau de Kubernetes pour les afficher dans la console d’administration.wandb-prometheus: le serveur Prometheus, qui capture les métriques de différents composants pour les afficher dans la console d’administration.wandb-parquet: un microservice backend distinct du pod wandb-app qui exporte les données de la base de données vers le stockage d’objets au format Parquet.wandb-weave: un autre microservice backend qui charge les tables de requête dans l’UI et prend en charge diverses fonctionnalités essentielles de l’application.wandb-weave-trace: un framework pour le suivi, l’expérimentation, l’évaluation, le déploiement et l’amélioration d’applications basées sur des LLM. Le framework est accessible via le pod wandb-app.
Voir Accéder à la console de gestion de l’opérateur Kubernetes W&B.
Exécutez la commande suivante sur un hôte ayant accès au cluster Kubernetes :
kubectl port-forward svc/wandb-console 8082
https://localhost:8082/.
Voir Accéder à la console de gestion de l’opérateur Kubernetes W&B pour savoir comment obtenir le mot de passe (option 2).
Le pod de l’application s’appelle wandb-app-xxx.
kubectl get pods
kubectl logs wandb-XXXXX-XXXXX
