> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Créer un job Launch

> Créez des jobs W&B Launch à partir de dépôts Git, d’artifacts de code ou d’images Docker à l’aide de la commande wandb launch.

<Card title="Essayer dans Colab" href="https://colab.research.google.com/drive/1wX0OSVxZJDHRsZaOaOEDx-lLUrO1hHgP" icon="code" />

Cette page explique comment créer des jobs W\&B Launch pour reproduire des runs W\&B à la demande. Les jobs Launch servent de modèles pour reproduire des runs W\&B. Ce sont des artifacts W\&B qui capturent le code source, les dépendances et les entrées nécessaires à l’exécution d’une charge de travail.

Reportez-vous à cette page pour empaqueter une charge de travail à partir d’un dépôt Git, d’un répertoire de code local ou d’une image Docker préconstruite, afin de pouvoir la réexécuter ultérieurement avec d’autres paramètres ou sur une autre infrastructure.

Créez et exécutez des jobs avec la commande `wandb launch`.

<Note>
  Pour créer un job sans le soumettre pour exécution, utilisez la commande `wandb job create`. Pour plus d’informations, consultez la [documentation de référence de la commande](/fr/products/wandb/ref/cli/wandb-job/wandb-job-create).
</Note>

<h2 id="git-jobs">
  Jobs basés sur Git
</h2>

Utilisez un job basé sur Git lorsque votre code source est hébergé dans un dépôt distant et que vous souhaitez que Launch le clone à partir d’un commit, d’une branche ou d’un tag précis. W\&B Launch clone le code et les autres ressources suivies à partir d’un commit, d’une branche ou d’un tag d’un dépôt Git distant. Utilisez l’option `--uri` ou `-u` pour indiquer l’URI qui contient le code, et éventuellement l’option facultative `--build-context` pour indiquer un sous-répertoire.

Exécutez un job « hello world » à partir d’un dépôt Git avec la commande suivante :

```bash theme={"system"}
wandb launch --uri "https://github.com/wandb/launch-jobs.git" --build-context jobs/hello_world --dockerfile Dockerfile.wandb --project "hello-world" --job-name "hello-world" --entry-point "python job.py"
```

La commande effectue les opérations suivantes :

1. Clone le [dépôt W\&B Launch jobs](https://github.com/wandb/launch-jobs) dans un répertoire temporaire.
2. Crée un job nommé `hello-world-git` dans le projet `hello`. Le job est associé au dernier commit (HEAD) de la branche par défaut du dépôt.
3. Construit une image de conteneur à partir du répertoire `jobs/hello_world` et du fichier `Dockerfile.wandb`.
4. Démarre le conteneur et exécute `python job.py`.

Une fois la commande terminée, vous disposez dans le projet `hello-world` d’un job basé sur Git réutilisable, que d’autres utilisateurs ou automatisations peuvent réexécuter avec `wandb launch`.

Pour construire un job à partir d’une branche ou d’un hash de commit spécifique, ajoutez l’argument `-g`, `--git-hash`. Pour obtenir la liste complète des arguments, exécutez `wandb launch --help`.

<h3 id="remote-url-format">
  Format de l’URL distante
</h3>

Le dépôt distant Git associé à un job Launch peut utiliser une URL HTTPS ou SSH. Le type d’URL détermine le protocole utilisé pour récupérer le code source du job.

| Type d’URL distante | Format de l’URL | Exigences d’accès et d’authentification |
| - | - | - |
| HTTPS | `https://github.com/organization/repository.git` | Nom d’utilisateur et mot de passe pour s’authentifier auprès du dépôt distant Git |
| SSH | `git@github.com:organization/repository.git` | Clé SSH pour s’authentifier auprès du dépôt distant Git |

Le format exact de l’URL varie selon l’hébergeur. Les jobs créés avec `wandb launch --uri` utilisent le protocole de transfert indiqué dans la valeur `--uri` fournie.

<h2 id="code-artifact-jobs">
  Jobs d’artifact de code
</h2>

Utilisez un job d’artifact de code lorsque votre code source se trouve dans un répertoire local et non dans un dépôt Git distant. Vous pouvez créer des jobs à partir de n’importe quel code source stocké dans un artifact W\&B. Indiquez un répertoire local avec l’argument `--uri` ou `-u` pour créer un nouvel artifact de code et un nouveau job.

Pour commencer, créez un répertoire vide et ajoutez-y un script Python nommé `main.py` contenant le code suivant :

```python theme={"system"}
import wandb

with wandb.init() as run:
    run.log({"metric": 0.5})
```

Ajoutez un fichier `requirements.txt` contenant ce qui suit :

```text theme={"system"}
wandb>=0.17.1
```

Journalisez le répertoire en tant qu’artifact de code et lancez un job avec la commande suivante :

```bash theme={"system"}
wandb launch --uri . --job-name hello-world-code --project launch-quickstart --entry-point "python main.py"
```

La commande précédente effectue les opérations suivantes :

1. Journalise le répertoire courant en tant qu’artifact de code nommé `hello-world-code`.
2. Crée un job nommé `hello-world-code` dans le projet `launch-quickstart`.
3. Construit une image de conteneur à partir du répertoire courant et du Dockerfile par défaut de Launch. Le Dockerfile par défaut installe le fichier `requirements.txt` et définit le point d’entrée sur `python main.py`.

Une fois la commande terminée, votre code local est capturé en tant qu’artifact de code W\&B et associé à un job réutilisable dans le projet `launch-quickstart`.

<h2 id="image-jobs">
  Jobs d’image
</h2>

Vous pouvez également créer des jobs à partir d’images Docker prédéfinies. Cette approche est utile lorsque vous disposez déjà d’un système de build pour votre code de ML, ou lorsque vous ne prévoyez pas de modifier le code ni les exigences du job, mais souhaitez tester différents hyperparamètres ou différentes échelles d’infrastructure.

Launch récupère l’image depuis un registre Docker et l’exécute avec le point d’entrée spécifié, ou avec le point d’entrée par défaut si aucun n’est indiqué. Transmettez un tag d’image complet à l’option `--docker-image` pour créer et exécuter un job à partir d’une image Docker.

Pour exécuter un job à partir d’une image prédéfinie, utilisez la commande suivante :

```bash theme={"system"}
wandb launch --docker-image "wandb/job_hello_world:main" --project "hello-world"           
```

<h2 id="automatic-job-creation">
  Création automatique de jobs
</h2>

Outre les jobs que vous créez explicitement avec `wandb launch`, W\&B peut créer des jobs pour vous lorsque vous exécutez du code suivi. W\&B crée et suit automatiquement un job pour tout run dont le code source est suivi, même si ce run n’a pas été créé avec Launch. Un run est considéré comme ayant un code source suivi si l’une des trois conditions suivantes est remplie :

* Le run est associé à un dépôt Git distant et à un hash de commit.
* Le run a journalisé un artifact de code. Voir [`Run.log_code`](/fr/products/wandb/ref/python/experiments/run#log_code).
* Le run a été exécuté dans un conteneur Docker dont la variable d’environnement `WANDB_DOCKER` est définie sur un tag d’image.

Si W\&B crée automatiquement votre job Launch à partir d’un run W\&B, W\&B déduit l’URL du dépôt Git distant à partir du dépôt Git local.

<h3 id="launch-job-names">
  Noms des jobs Launch
</h3>

Par défaut, W\&B génère automatiquement un nom de job. Ce nom dépend de la manière dont le job est créé (GitHub, artifact de code ou image Docker). Vous pouvez également définir le nom d’un job Launch à l’aide de variables d’environnement ou du SDK Python W\&B.

Le tableau suivant présente la convention de nommage appliquée par défaut aux jobs selon leur source :

| Source | Convention de nommage |
| - | - |
| GitHub | `job-[GIT-REMOTE-URL]-[PATH-TO-SCRIPT]` |
| Artifact de code | `job-[CODE-ARTIFACT-NAME]` |
| Image Docker | `job-[IMAGE-NAME]` |

Nommez votre job à l’aide d’une variable d’environnement W\&B ou du SDK Python W\&B.

<Tabs>
  <Tab title="Variable d’environnement">
    Définissez la variable d’environnement `WANDB_JOB_NAME` sur le nom de job de votre choix. Par exemple :

    ```bash theme={"system"}
    WANDB_JOB_NAME=awesome-job-name
    ```
  </Tab>

  <Tab title="SDK Python W&B">
    Définissez le nom de votre job avec `wandb.Settings`, puis transmettez cet objet lors de l’initialisation de W\&B avec `wandb.init()`. Par exemple :

    ```python theme={"system"}
    settings = wandb.Settings(job_name="my-job-name")
    wandb.init(settings=settings)
    ```
  </Tab>
</Tabs>

<Note>
  Pour les jobs d’image Docker, W\&B ajoute automatiquement l’alias de version comme alias du job.
</Note>

<h2 id="containerization">
  Conteneurisation
</h2>

Les jobs s’exécutent dans un conteneur. Les jobs d’image utilisent une image Docker préconstruite, tandis que les jobs Git et les jobs d’artifact de code nécessitent une étape de build du conteneur.

Vous pouvez personnaliser la conteneurisation des jobs à l’aide des arguments de `wandb launch` et des fichiers inclus dans le code source du job. Les sections suivantes expliquent comment contrôler le contexte de build, fournir un Dockerfile personnalisé et gérer les dépendances Python.

<h3 id="build-context">
  Contexte de build
</h3>

Le terme « contexte de build » désigne l’arborescence de fichiers et de répertoires envoyée au démon Docker pour construire une image de conteneur. Par défaut, Launch utilise la racine du code source du job comme contexte de build. Pour définir un sous-répertoire comme contexte de build, utilisez l’argument `--build-context` de `wandb launch` lors de la création et du lancement d’un job.

<Note>
  L’argument `--build-context` est utile pour les jobs basés sur Git qui pointent vers un monodépôt contenant plusieurs projets. En définissant un sous-répertoire comme contexte de build, vous pouvez construire une image de conteneur pour un projet spécifique du monodépôt.

  Consultez [Jobs basés sur Git](#git-jobs) pour découvrir comment utiliser l’argument `--build-context` avec le dépôt officiel de jobs W\&B Launch.
</Note>

<h3 id="dockerfile">
  Dockerfile
</h3>

Le Dockerfile est un fichier texte qui contient les instructions de création d’une image Docker. Par défaut, Launch utilise un Dockerfile standard qui installe le fichier `requirements.txt`. Pour utiliser un Dockerfile personnalisé, indiquez le chemin du fichier avec l’argument `--dockerfile` de `wandb launch`.

Indiquez le chemin du Dockerfile par rapport au contexte de build. Par exemple, si le contexte de build est `jobs/hello_world` et que le Dockerfile se trouve dans le répertoire `jobs/hello_world`, définissez l’argument `--dockerfile` sur `Dockerfile.wandb`. Consultez [Jobs basés sur Git](#git-jobs) pour découvrir comment utiliser l’argument `--dockerfile` avec le dépôt officiel des jobs W\&B Launch.

<h3 id="requirements-file">
  Fichier d’exigences
</h3>

Si aucun Dockerfile personnalisé n’est fourni, Launch recherche dans le contexte de build les dépendances Python à installer. Si un fichier `requirements.txt` se trouve à la racine du contexte de build, Launch installe les dépendances répertoriées dans ce fichier. Sinon, s’il trouve un fichier `pyproject.toml`, Launch installe les dépendances indiquées dans la section `project.dependencies`.