> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/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’artefacts 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="python" />

Cette page vous montre comment créer des jobs W\&B Launch afin de pouvoir reproduire des runs W\&B à la demande. Les jobs Launch servent de modèle pour reproduire des runs W\&B. Les jobs sont des artefacts W\&B qui capturent le code source, les dépendances et les entrées requises pour exécuter une charge de travail.

Utilisez cette page lorsque vous souhaitez 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 plus tard avec des paramètres différents ou sur une infrastructure différente.

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

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

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

Utilisez un job basé sur Git lorsque votre code source se trouve 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 spécifiques. W\&B Launch clone le code et d'autres ressources suivies à partir d'un commit, d'une branche ou d'un tag dans un dépôt Git distant. Utilisez l'option `--uri` ou `-u` pour spécifier l'URI qui contient le code, et éventuellement l'option `--build-context` pour spécifier un sous-répertoire.

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

```bash theme={null}
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 de jobs W\&B Launch](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 commit correspondant au 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 d’un job réutilisable basé sur Git dans le projet `hello-world`, que d’autres utilisateurs ou automatisations peuvent relancer avec `wandb launch`.

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

<div id="remote-url-format">
  ### Format des URL distantes
</div>

Le dépôt Git distant associé à un job Launch peut avoir 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 d’URL                                     | Exigences pour l’accès et l’authentification                                         |
| ------------------- | ------------------------------------------------ | ------------------------------------------------------------------------------------ |
| HTTPS               | `https://github.com/organization/repository.git` | nom d’utilisateur et mot de passe pour vous authentifier auprès du dépôt Git distant |
| SSH                 | `git@github.com:organization/repository.git`     | clé SSH pour vous authentifier auprès du dépôt Git distant                           |

Notez que le format exact de l’URL varie selon le fournisseur d’hébergement. Les jobs créés avec `wandb launch --uri` utilisent le protocole de transfert spécifié dans l’argument `--uri` fourni.

<div id="code-artifact-jobs">
  ## Jobs d’artefact de code
</div>

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

Pour commencer, créez un répertoire vide et ajoutez un script Python nommé `main.py` avec le contenu suivant :

```python theme={null}
import wandb

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

Ajoutez un fichier `requirements.txt` avec le contenu suivant :

```text theme={null}
wandb>=0.17.1
```

Enregistrez le répertoire en tant qu’artefact de code et lancez un job à l’aide de la commande suivante :

```bash theme={null}
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. Enregistre le répertoire actuel en tant qu’artefact de code nommé `hello-world-code`.
2. Crée un job nommé `hello-world-code` dans le projet `launch-quickstart`.
3. Crée une image de conteneur à partir du répertoire actuel 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é sous forme d’artefact de code W\&B et associé à un job réutilisable dans le projet `launch-quickstart`.

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

Vous pouvez également créer des jobs à partir d’images Docker prêtes à l’emploi. Cette approche est utile si vous disposez déjà d’un système de build bien établi pour votre code ML, ou si vous ne prévoyez pas d’ajuster le code ni les exigences du job, tout en souhaitant quand même expérimenter avec des hyperparamètres ou différentes tailles d’infrastructure.

Launch récupère l’image depuis un registre Docker puis 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é. Fournissez un tag d’image complet à l’option `--docker-image` pour créer et exécuter un job à partir d’une image Docker.

Exécutez un job à partir d’une image prédéfinie avec la commande suivante :

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

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

En plus des jobs que vous créez explicitement avec `wandb launch`, W\&B peut créer des jobs pour vous comme effet secondaire de l’exécution de 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. Les runs sont considérés comme ayant un code source suivi si l’une des trois conditions suivantes est remplie :

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

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

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

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, artefact 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 décrit la convention de nommage des jobs utilisée par défaut en fonction de la source du job :

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

Nommez votre job avec une variable d’environnement W\&B ou avec le SDK Python W\&B.

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

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

  <Tab title="W&B Python SDK">
    Définissez le nom de votre job avec `wandb.Settings`. Passez ensuite cet objet lorsque vous initialisez W\&B avec `wandb.init()`. Par exemple :

    ```python theme={null}
    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 aux alias du job.
</Note>

<div id="containerization">
  ## Conteneurisation
</div>

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’artefacts de code nécessitent une étape de build du conteneur.

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

<div id="build-context">
  ### Contexte de build
</div>

Le terme build context désigne l’arborescence des fichiers et répertoires envoyés au démon Docker pour créer une image de conteneur. Par défaut, Launch utilise la racine du code source du job comme contexte de build. Pour spécifier un sous-répertoire comme contexte de build, utilisez l’argument `--build-context` de `wandb launch` lorsque vous créez et lancez un job.

<Note>
  L’argument `--build-context` est utile lorsque vous travaillez avec des jobs basés sur Git qui se réfèrent à un monorepo contenant plusieurs projets. En spécifiant un sous-répertoire comme contexte de build, vous pouvez créer une image de conteneur pour un projet spécifique au sein du monorepo.

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

<div id="dockerfile">
  ### Dockerfile
</div>

Le Dockerfile est un fichier texte qui contient des instructions pour construire une image Docker. Par défaut, Launch utilise un Dockerfile qui installe le fichier `requirements.txt`. Pour utiliser un Dockerfile personnalisé, indiquez le chemin d’accès au 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`. Voir [jobs basés sur Git](#git-jobs) pour voir comment utiliser l’argument `--dockerfile` avec le dépôt officiel des jobs Launch de W\&B.

<div id="requirements-file">
  ### Fichier `requirements`
</div>

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