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

# Bibliothèque de modèles de blueprints Devin

> Configurez les environnements Devin à l'aide de modèles de blueprints pour les langages courants, les registres privés et l'infrastructure enterprise.

Des blueprints à copier-coller pour les langages et cas d'usage courants. Combinez-les pour composer votre configuration complète. Les exemples utilisent Bash sous Linux ; remplacez les hôtes, périmètres et commandes donnés en exemple par les vôtres.

Pour le détail de chaque champ, consultez la [référence Blueprint](https://docs.devin.ai/fr/onboard-devin/environment/blueprint-reference.md).

> [!NOTE]
>
> **Secrets :** configurez les secrets nommés dans l'onglet **Secrets** de chaque éditeur de blueprint. Les étapes de build reçoivent les secrets applicables du blueprint. Pendant une session, assurez-vous que chaque commande reçoit les secrets dont elle a besoin : les secrets à périmètre repo nécessitent des liaisons d'environnement `exec` explicites, par exemple `env={"REGISTRY_TOKEN": "secret:repo:owner/repo:REGISTRY_TOKEN"}`. Consultez [Secrets](https://docs.devin.ai/fr/product-guides/secrets.md). Ne codez jamais en dur des credentials dans votre blueprint.

> [!WARNING]
>
> **Les étapes de build ne sont pas des hooks de démarrage de session.** `initialize` et `maintenance` s'exécutent pendant la construction des snapshots ; `maintenance` n'est pas exécuté automatiquement au démarrage d'une session. `knowledge` fournit des instructions à Devin, et non des hooks exécutables.
>
> Ne laissez pas de credentials dans des fichiers persistants, y compris `$ENVRC`. Le nettoyage des snapshots supprime les fichiers de secrets injectés par Devin, mais pas les fichiers quelconques créés par vos commandes. Utilisez les références de variables littérales prises en charge par l'outil concerné, ou transmettez les credentials dans l'environnement de la commande. Lorsqu'un outil exige des fichiers de credentials, créez-les le temps d'une seule opération et supprimez-les avant qu'elle ne se termine. Répétez cette configuration explicitement au besoin dans une session.

***

## Démarrage rapide

Blueprints minimaux pour les configurations les plus courantes. Copiez-en un, collez-le dans l’éditeur de blueprints, et le tour est joué.

> [accordion] Projet Node.js
>
> ```yaml theme={null}
> initialize: |
>   npm install -g pnpm
>
> maintenance: |
>   pnpm install
>
> knowledge:
>   - name: lint
>     contents: |
>       Exécutez `pnpm lint` pour vérifier les erreurs.
>   - name: test
>     contents: |
>       Exécutez `pnpm test` pour lancer la suite complète.
> ```

> [accordion] Projet Python
>
> ```yaml theme={null}
> initialize: |
>   curl -LsSf https://astral.sh/uv/install.sh | sh
>
> maintenance: |
>   uv sync
>
> knowledge:
>   - name: lint
>     contents: |
>       Exécutez `uv run ruff check .` pour lancer le lint.
>   - name: test
>     contents: |
>       Exécutez `uv run pytest` pour lancer la suite complète.
> ```

> [accordion] Projet full-stack (Node + Python)
>
> ```yaml theme={null}
> initialize:
>   - name: Installer pnpm
>     run: npm install -g pnpm
>   - name: Install uv
>     run: curl -LsSf https://astral.sh/uv/install.sh | sh
>
> maintenance:
>   - name: Dépendances frontend
>     run: (cd frontend && pnpm install)
>   - name: Dépendances backend
>     run: (cd backend && uv sync)
>
> knowledge:
>   - name: structure
>     contents: |
>       - `frontend/` — application React (pnpm)
>       - `backend/` — API Python (uv)
>   - name: test
>     contents: |
>       Frontend: cd frontend && pnpm test
>       Backend: cd backend && uv run pytest
> ```

***

## Blueprints du dépôt

Étapes de build propres à chaque dépôt, gestion des dépendances et entrées Knowledge. Définissez-les dans **Settings > Environnement > Blueprints > \[votre dépôt]**.

### Python

> [tab] uv (recommandé)
>
> Configuration recommandée pour les projets Python qui utilisent [uv](https://docs.astral.sh/uv/) pour la gestion des dépendances.
>
> ```yaml theme={null}
> initialize: |
>   curl -LsSf https://astral.sh/uv/install.sh | sh
>
> maintenance: |
>   uv sync
>
> knowledge:
>   - name: lint
>     contents: |
>       uv run ruff check .
>
>       Correction automatique :
>       uv run ruff check --fix .
>
>   - name: test
>     contents: |
>       uv run pytest
>
>   - name: build
>     contents: |
>       uv run python -m build
> ```

> [tab] pip + venv
>
> Configuration Python traditionnelle avec pip et venv. À utiliser lorsque votre projet s’appuie sur `requirements.txt`.
>
> ```yaml theme={null}
> initialize: |
>   python3 -m venv .venv
>
> maintenance: |
>   source .venv/bin/activate
>   pip install -r requirements.txt
>
> knowledge:
>   - name: lint
>     contents: |
>       source .venv/bin/activate
>       flake8 .
>
>   - name: test
>     contents: |
>       source .venv/bin/activate
>       pytest
>
>   - name: build
>     contents: |
>       source .venv/bin/activate
>       python -m build
> ```

### Node.js

> [tab] npm
>
> Configuration Node.js par défaut avec npm.
>
> ```yaml theme={null}
> initialize: |
>   nvm install 20
>   nvm use 20
>
> maintenance: |
>   npm install
>
> knowledge:
>   - name: lint
>     contents: |
>       npx eslint .
>
>   - name: test
>     contents: |
>       npm test
>
>   - name: build
>     contents: |
>       npm run build
> ```
>
> > [!NOTE]
> >
> > Utilisez `npm install` (et non `npm ci`) dans `maintenance`. Cette commande effectue une mise à jour incrémentielle, tandis que `npm ci` supprime `node_modules` et réinstalle tout depuis zéro à chaque exécution de la commande.

> [tab] pnpm
>
> Pour les projets qui utilisent pnpm.
>
> ```yaml theme={null}
> initialize: |
>   npm install -g pnpm
>
> maintenance: |
>   pnpm install --frozen-lockfile
>
> knowledge:
>   - name: lint
>     contents: |
>       pnpm lint
>
>   - name: test
>     contents: |
>       pnpm test
>
>   - name: build
>     contents: |
>       pnpm build
> ```

### Go

Configuration Go standard avec modules.

```yaml theme={null}
initialize: |
  GO_VERSION=1.23.5
  ARCH=$(dpkg --print-architecture)
  curl -fsSL "https://go.dev/dl/go${GO_VERSION}.linux-${ARCH}.tar.gz" \
    | sudo tar -xz -C /usr/local
  echo 'export PATH="/usr/local/go/bin:$HOME/go/bin:$PATH"' \
    | sudo tee /etc/profile.d/golang.sh > /dev/null

  go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest

maintenance: |
  go mod download

knowledge:
  - name: lint
    contents: |
      golangci-lint run

  - name: test
    contents: |
      go test ./...

  - name: build
    contents: |
      go build ./...
```

### Java

> [tab] Gradle
>
> Configuration de Java avec Gradle.
>
> > [!NOTE]
> >
> > JDK 17 est **préinstallé** sur l’image de base de Devin. Ignorez l’étape d’installation du JDK si l’OpenJDK 17 par défaut vous convient.
>
> ```yaml theme={null}
> initialize:
>   - name: Install JDK 17
>     run: |
>       sudo apt-get update -qq
>       sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq openjdk-17-jdk-headless
>       echo 'export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64' \
>         | sudo tee /etc/profile.d/java.sh > /dev/null
>
>   - name: Install Gradle
>     run: |
>       GRADLE_VERSION=8.12
>       curl -fsSL "https://services.gradle.org/distributions/gradle-${GRADLE_VERSION}-bin.zip" \
>         -o /tmp/gradle.zip
>       sudo unzip -qo /tmp/gradle.zip -d /opt
>       sudo ln -sf /opt/gradle-${GRADLE_VERSION}/bin/gradle /usr/local/bin/gradle
>       rm /tmp/gradle.zip
>
> maintenance: |
>   ./gradlew dependencies
>
> knowledge:
>   - name: lint
>     contents: |
>       ./gradlew check
>
>   - name: test
>     contents: |
>       ./gradlew test
>
>   - name: build
>     contents: |
>       ./gradlew build
> ```

> [tab] Maven
>
> Configuration de Java avec Maven.
>
> > [!NOTE]
> >
> > JDK 17 est **préinstallé** sur l’image de base de Devin. Ignorez l’étape d’installation du JDK si l’OpenJDK 17 par défaut vous convient.
>
> ```yaml theme={null}
> initialize:
>   - name: Install JDK 17
>     run: |
>       sudo apt-get update -qq
>       sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq openjdk-17-jdk-headless
>       echo 'export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64' \
>         | sudo tee /etc/profile.d/java.sh > /dev/null
>
>   - name: Install Maven
>     run: |
>       MAVEN_VERSION=3.9.9
>       curl -fsSL "https://archive.apache.org/dist/maven/maven-3/${MAVEN_VERSION}/binaries/apache-maven-${MAVEN_VERSION}-bin.tar.gz" \
>         | sudo tar -xz -C /opt
>       sudo ln -sf /opt/apache-maven-${MAVEN_VERSION}/bin/mvn /usr/local/bin/mvn
>
> maintenance: |
>   mvn dependency:resolve
>
> knowledge:
>   - name: test
>     contents: |
>       mvn test
>
>   - name: build
>     contents: |
>       mvn package
> ```

### Ruby on Rails

Configuration de Rails avec PostgreSQL.

```yaml theme={null}
initialize:
  - name: Install Ruby 3.3
    run: |
      sudo apt-get update -qq
      sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq ruby-full libpq-dev postgresql-client

maintenance: |
  bundle install
  rails db:migrate

knowledge:
  - name: lint
    contents: |
      bundle exec rubocop

  - name: test
    contents: |
      bundle exec rspec

  - name: build
    contents: |
      rails assets:precompile
```

### Rust

Configuration standard de Rust avec Cargo.

> [!NOTE]
>
> **Rust** (via rustup) et **Cargo** sont **préinstallés** sur l’image de base de Devin. Passez l’étape d’installation si la toolchain stable par défaut vous convient. Il vous suffit de récupérer les dépendances.

```yaml theme={null}
initialize: |
  curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
  source ~/.cargo/env

maintenance: |
  cargo fetch

knowledge:
  - name: lint
    contents: |
      cargo clippy -- -D warnings

  - name: test
    contents: |
      cargo test

  - name: build
    contents: |
      cargo build --release
```

### Monorepos

> [tab] Multilingue
>
> Monorepo avec un frontend Node.js et un backend Python. Chaque sous-projet a ses propres entrées Knowledge.
>
> ```yaml theme={null}
> initialize:
>   - name: Installer pnpm
>     run: npm install -g pnpm
>   - name: Installer uv
>     run: curl -LsSf https://astral.sh/uv/install.sh | sh
>
> maintenance:
>   - name: Installer les dépendances du frontend
>     run: (cd packages/frontend && pnpm install)
>   - name: Installer les dépendances du backend
>     run: (cd packages/backend && uv sync)
>   - name: Build de la bibliothèque partagée
>     run: (cd packages/shared && pnpm install && pnpm build)
>
> knowledge:
>   - name: structure
>     contents: |
>       Il s'agit d'un monorepo avec trois packages :
>       - `packages/frontend` — application React (TypeScript, pnpm)
>       - `packages/backend` — API Python (FastAPI, uv)
>       - `packages/shared` — utilitaires TypeScript partagés (doivent être buildés avant le frontend)
>   - name: frontend
>     contents: |
>       Exécutez `cd packages/frontend && pnpm dev` pour démarrer le serveur de développement.
>       Exécutez `cd packages/frontend && pnpm lint` pour lancer le linting.
>       Exécutez `cd packages/frontend && pnpm test` pour lancer les tests.
>   - name: backend
>     contents: |
>       Exécutez `cd packages/backend && uv run uvicorn app.main:app --reload` pour démarrer l'API.
>       Exécutez `cd packages/backend && uv run ruff check .` pour lancer le linting.
>       Exécutez `cd packages/backend && uv run pytest` pour lancer les tests.
> ```
>
> > [!TIP]
> >
> > Utilisez des subshells `(cd dir && command)` plutôt que `cd dir && command` afin que le répertoire de travail soit réinitialisé entre les étapes.

> [tab] Versions multiples de JDK
>
> Monorepo Java dans lequel différents services nécessitent différentes versions de JDK. Installez les deux JDK lors de l'initialisation, puis utilisez les entrées `knowledge` pour indiquer à Devin quelle valeur de `JAVA_HOME` utiliser pour chaque service.
>
> ```yaml theme={null}
> initialize:
>   - name: Installer JDK 17 (principal)
>     run: |
>       sudo apt-get update -qq
>       sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq openjdk-17-jdk-headless
>       echo 'export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64' \
>         | sudo tee /etc/profile.d/java.sh > /dev/null
>
>   - name: Installer JDK 11 (service ancien)
>     run: |
>       sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq openjdk-11-jdk-headless
>
> maintenance:
>   - name: Préchauffer les caches de dépendances
>     run: |
>       export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
>       (cd services/api && ./gradlew dependencies --refresh-dependencies)
>
>       export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
>       (cd services/legacy && ./gradlew dependencies --refresh-dependencies)
>
> knowledge:
>   - name: build_api
>     contents: |
>       Builder le service API (JDK 17) :
>         JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64 \
>         cd services/api && ./gradlew clean build
>   - name: build_legacy
>     contents: |
>       Builder le service ancien (JDK 11) :
>         JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64 \
>         cd services/legacy && ./gradlew clean build
>   - name: test_all
>     contents: |
>       Exécuter les tests pour tous les services :
>         JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64 \
>         (cd services/api && ./gradlew test)
>
>         JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64 \
>         (cd services/legacy && ./gradlew test)
> ```

***

## Registres de packages privés

Configurez les gestionnaires de paquets pour résoudre les dépendances depuis des registres privés. Définissez ces paramètres dans **Settings > Environment > Blueprints > Org-wide setup** (ou par repo si un seul repo en a besoin).

> [!WARNING]
>
> **Stockez des références, pas des credentials en clair.** Les délimiteurs heredoc entre quotes tels que `<<'EOF'` préservent les références de variables dans le fichier. npm, Yarn Berry, Maven et Gradle savent résoudre les références ci-dessous au moment de leur exécution. pip, en revanche, n’interprète pas les variables shell dans `pip.conf` : utilisez donc des variables d’environnement. Les fichiers de setup du shell doivent être sourcés explicitement dans la même commande que l’outil ; ne partez pas du principe qu’un nouveau shell les source ou rafraîchit les credentials.
>
> Les URL écrites directement dans une configuration persistante, comme un index Cargo, un mirror Docker ou un mirror APT, ne doivent pas contenir de credentials. Conservez l’authentification dans les secrets distincts indiqués par chaque template.
>
> Si vous avez utilisé un ancien template qui écrivait des credentials sur le disque, supprimez ces fichiers et effectuez un rebuild à partir d’une base propre plutôt que d’un snapshot qui les contient. Effectuez une rotation des credentials susceptibles d’avoir été compromis.

> [!NOTE]
>
> Si votre registre privé utilise une CA d’entreprise, commencez par vérifier que le [certificat d’autorité de certification](#corporate-ca-certificate) est installé au niveau Enterprise. La configuration ci-dessous suppose que la confiance HTTPS est déjà établie.

### Registres Node.js

> [tab] npm (scoped)
>
> Configurez npm pour récupérer les packages d’un scope (par ex. `@myorg/*`) à partir d’un registre privé, tandis que les packages publics continuent de provenir du registre npm par défaut.
>
> > [accordion] Secrets requis
> >
> > * `GITHUB_PACKAGES_TOKEN` — Jeton d’accès personnel ou jeton GitHub App avec le périmètre `read:packages`
>
> ```yaml theme={null}
> maintenance:
>   - name: Configure npm scoped registry
>     run: |
>       npm config set @myorg:registry https://npm.pkg.github.com
>       npm config set //npm.pkg.github.com/:_authToken '${GITHUB_PACKAGES_TOKEN}'
> ```
>
> > [!TIP]
> >
> > Remplacez `@myorg` par votre scope npm. URL courantes de registres privés :
> >
> > * **GitHub Packages:** `https://npm.pkg.github.com`
> > * **Artifactory:** `https://artifactory.example.com/artifactory/api/npm/npm-virtual`
> > * **Nexus:** `https://nexus.example.com/repository/npm-group`
> > * **GitLab:** `https://gitlab.example.com/api/v4/packages/npm`
> > * **AWS CodeArtifact:** `https://<domain>.d.codeartifact.<region>.amazonaws.com/npm/<repo>`

> [tab] npm (miroir complet)
>
> Faites passer **tous** les packages npm par votre registre privé (et pas seulement les packages d’un scope).
>
> > [accordion] Secrets requis
> >
> > * `NPM_REGISTRY_URL` — URL complète de votre registre npm (par ex. `https://artifactory.example.com/artifactory/api/npm/npm-virtual`)
> > * `NPM_REGISTRY_HOST` — Nom d’hôte uniquement, sans protocole (par ex. `artifactory.example.com`)
> > * `REGISTRY_TOKEN` — Jeton d’authentification npm pour le registre
>
> ```yaml theme={null}
> maintenance:
>   - name: Configure npm to use private registry
>     run: |
>       npm config set registry '${NPM_REGISTRY_URL}'
>       npm config set "//${NPM_REGISTRY_HOST}/:_authToken" '${REGISTRY_TOKEN}'
>       npm config set strict-ssl true
> ```

> [tab] pnpm
>
> Configurez pnpm pour récupérer des packages à partir d’un registre privé.
>
> > [accordion] Secrets requis
> >
> > * `NPM_REGISTRY_URL` — URL complète de votre registre npm
> > * `NPM_REGISTRY_HOST` — Nom d’hôte uniquement, sans protocole
> > * `REGISTRY_TOKEN` — Jeton d’authentification npm pour le registre
>
> ```yaml theme={null}
> initialize:
>   - name: Install pnpm
>     run: npm install -g pnpm
>
> maintenance:
>   - name: Configure pnpm for private registry
>     run: |
>       npm config set registry '${NPM_REGISTRY_URL}'
>       npm config set "//${NPM_REGISTRY_HOST}/:_authToken" '${REGISTRY_TOKEN}'
> ```

> [tab] Yarn
>
> Configurez Yarn (Classic v1 ou Berry v2+) pour récupérer des packages à partir d’un registre privé.
>
> > [accordion] Secrets requis
> >
> > * `NPM_REGISTRY_URL` — URL complète de votre registre npm/Yarn
> > * `REGISTRY_TOKEN` — Jeton d’authentification pour le registre
>
> **Yarn Classic (v1) :**
>
> ```yaml theme={null}
> initialize:
>   - name: Install Yarn Classic
>     run: npm install -g yarn
>
> maintenance:
>   - name: Configure Yarn for private registry
>     run: |
>       npm config set registry '${NPM_REGISTRY_URL}'
>       npm config set //registry.example.com/:_authToken '${REGISTRY_TOKEN}'
> ```
>
> Remplacez `registry.example.com` par l’hôte de votre registre. Yarn Classic lit le fichier `.npmrc` de npm.
>
> **Yarn Berry (v2+) :**
>
> ```yaml theme={null}
> maintenance:
>   - name: Configure Yarn Berry for private registry
>     run: |
>       yarn config set npmRegistryServer '${NPM_REGISTRY_URL}'
>       yarn config set npmAuthToken '${REGISTRY_TOKEN}'
>       # Pour les packages d’un scope :
>       # yarn config set npmScopes.myorg.npmRegistryServer "https://npm.pkg.github.com"
>       # yarn config set npmScopes.myorg.npmAuthToken '${GITHUB_PACKAGES_TOKEN}'
> ```

### Registres Python

> [tab] pip / uv
>
> Configurez pip et uv pour récupérer les packages depuis votre registre PyPI privé (p. ex., Nexus, Artifactory).
>
> > [accordion] Secrets requis
> >
> > * `PYPI_REGISTRY_URL` — URL complète de votre index PyPI, y compris les identifiants si nécessaire (p. ex., `https://user:token@nexus.example.com/repository/pypi-proxy/simple`)
>
> ```yaml theme={null}
> maintenance:
>   - name: Configure pip/uv for private registry
>     run: |
>       mkdir -p ~/.config
>       cat > ~/.config/private-pypi.sh <<'EOF'
>       export PIP_INDEX_URL="$PYPI_REGISTRY_URL"
>       export UV_INDEX_URL="$PYPI_REGISTRY_URL"
>       EOF
>
> knowledge:
>   - name: private_python_packages
>     contents: |
>       With PYPI_REGISTRY_URL available in the command's environment, run:
>         source ~/.config/private-pypi.sh && uv sync
>       Or:
>         source ~/.config/private-pypi.sh && pip install -r requirements.txt
> ```
>
> Pour préparer les dépendances pendant un build, ajoutez la même commande `source ... &&` dans `maintenance`, après l'étape de configuration. Encodez en pourcentage les caractères spéciaux des credentials présents dans l'URL.
>
> > [!TIP]
> >
> > Modèles courants d'URL de registres PyPI :
> >
> > * **Artifactory :** `https://artifactory.example.com/artifactory/api/pypi/pypi-virtual/simple`
> > * **Nexus :** `https://nexus.example.com/repository/pypi-proxy/simple`
> > * **AWS CodeArtifact :** `https://aws:TOKEN@domain-owner.d.codeartifact.region.amazonaws.com/pypi/repo/simple/`
> > * **Azure Artifacts :** `https://pkgs.dev.azure.com/org/project/_packaging/feed/pypi/simple`
> > * **GitLab :** `https://gitlab.example.com/api/v4/groups/<group-id>/-/packages/pypi/simple`

> [tab] Poetry
>
> Configurez Poetry pour récupérer les packages depuis un registre PyPI privé.
>
> > [accordion] Secrets requis
> >
> > * `POETRY_REGISTRY_URL` — URL complète de votre registre compatible PyPI
> > * `REGISTRY_USER` — Nom d'utilisateur du registre
> > * `REGISTRY_PASS` — Mot de passe du registre ou jeton d'API
>
> ```yaml theme={null}
> initialize:
>   - name: Install Poetry
>     run: curl -sSL https://install.python-poetry.org | python3 -
>
> maintenance:
>   - name: Configure Poetry for private registry
>     run: |
>       poetry config repositories.private "$POETRY_REGISTRY_URL"
>       mkdir -p ~/.config
>       cat > ~/.config/private-poetry.sh <<'EOF'
>       export POETRY_HTTP_BASIC_PRIVATE_USERNAME="$REGISTRY_USER"
>       export POETRY_HTTP_BASIC_PRIVATE_PASSWORD="$REGISTRY_PASS"
>       EOF
>
> knowledge:
>   - name: private_poetry_packages
>     contents: |
>       With REGISTRY_USER and REGISTRY_PASS available, run:
>         source ~/.config/private-poetry.sh && poetry install
> ```
>
> Pour l'installation des dépendances, déclarez également la source de packages `private` dans le `pyproject.toml` de votre projet. `poetry config repositories.private` configure le repository de publication ; les credentials de l'environnement s'appliquent au nom de source correspondant.

### Registres JVM

> [tab] Maven
>
> Installez le JDK et configurez Maven pour faire transiter toute la résolution des dépendances par votre registre privé (p. ex. Artifactory, Nexus).
>
> > [!NOTE]
> >
> > Le JDK 17 est **préinstallé** sur l’image de base de Devin. Passez l’étape d’installation si l’OpenJDK 17 par défaut vous suffit. Vous n’avez besoin que de l’installation de Maven et de la configuration du registre.
>
> > [accordion] Secrets requis
> >
> > * `MAVEN_REGISTRY_URL` — URL de votre registre Maven (p. ex. `https://artifactory.example.com/artifactory/maven-virtual`)
> > * `REGISTRY_USER` — Nom d’utilisateur du registre
> > * `REGISTRY_PASS` — Mot de passe du registre ou jeton d’API
>
> ```yaml theme={null}
> initialize:
>   - name: Install JDK 17
>     run: |
>       sudo apt-get update -qq
>       sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq openjdk-17-jdk-headless
>       echo 'export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64' \
>         | sudo tee /etc/profile.d/java.sh > /dev/null
>
>   - name: Install Maven
>     run: |
>       MAVEN_VERSION=3.9.9
>       curl -fsSL "https://archive.apache.org/dist/maven/maven-3/${MAVEN_VERSION}/binaries/apache-maven-${MAVEN_VERSION}-bin.tar.gz" \
>         | sudo tar -xz -C /opt
>       sudo ln -sf /opt/apache-maven-${MAVEN_VERSION}/bin/mvn /usr/local/bin/mvn
>
> maintenance:
>   - name: Configure Maven for private registry
>     run: |
>       mkdir -p ~/.m2
>       cat > ~/.m2/settings.xml <<'EOF'
>       <settings>
>         <mirrors>
>           <mirror>
>             <id>private-registry</id>
>             <mirrorOf>*</mirrorOf>
>             <url>${env.MAVEN_REGISTRY_URL}</url>
>           </mirror>
>         </mirrors>
>         <servers>
>           <server>
>             <id>private-registry</id>
>             <username>${env.REGISTRY_USER}</username>
>             <password>${env.REGISTRY_PASS}</password>
>           </server>
>         </servers>
>       </settings>
>       EOF
> ```
>
> > [!TIP]
> >
> > Schémas d’URL courants pour les registres Maven :
> >
> > * **Artifactory:** `https://artifactory.example.com/artifactory/maven-virtual`
> > * **Nexus:** `https://nexus.example.com/repository/maven-public`
> > * **Azure Artifacts:** `https://pkgs.dev.azure.com/org/project/_packaging/feed/maven/v1`
> > * **GitHub Packages:** `https://maven.pkg.github.com`
> > * **GitLab:** `https://gitlab.example.com/api/v4/groups/<group-id>/-/packages/maven`
> > * **AWS CodeArtifact:** `https://<domain>.d.codeartifact.<region>.amazonaws.com/maven/<repo>`

> [tab] Gradle
>
> Installez le JDK et configurez Gradle pour résoudre l’ensemble des dépendances via votre registre privé.
>
> > [!NOTE]
> >
> > Le JDK 17 est **préinstallé** sur l’image de base de Devin. Ignorez l’étape d’installation du JDK si la version par défaut vous convient.
>
> > [accordion] Secrets requis
> >
> > * `GRADLE_REGISTRY_URL` — URL de votre registre Gradle/Maven
> > * `REGISTRY_USER` — Nom d’utilisateur du registre
> > * `REGISTRY_PASS` — Mot de passe du registre ou jeton d’API
>
> ```yaml theme={null}
> initialize:
>   - name: Install JDK 17
>     run: |
>       sudo apt-get update -qq
>       sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq openjdk-17-jdk-headless
>       echo 'export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64' \
>         | sudo tee /etc/profile.d/java.sh > /dev/null
>
>   - name: Install Gradle
>     run: |
>       GRADLE_VERSION=8.12
>       curl -fsSL "https://services.gradle.org/distributions/gradle-${GRADLE_VERSION}-bin.zip" \
>         -o /tmp/gradle.zip
>       sudo unzip -qo /tmp/gradle.zip -d /opt
>       sudo ln -sf /opt/gradle-${GRADLE_VERSION}/bin/gradle /usr/local/bin/gradle
>       rm /tmp/gradle.zip
>
> maintenance:
>   - name: Configure Gradle for private registry
>     run: |
>       mkdir -p ~/.gradle
>       cat > ~/.gradle/init.gradle <<'EOF'
>       allprojects {
>           repositories {
>               maven {
>                   url System.getenv("GRADLE_REGISTRY_URL")
>                   credentials {
>                       username = System.getenv("REGISTRY_USER")
>                       password = System.getenv("REGISTRY_PASS")
>                   }
>                   allowInsecureProtocol = false
>               }
>           }
>       }
>       EOF
> ```

### Autres registres

> [accordion] Proxy de modules Go
>
> Installez Go et configurez-le pour qu'il résolve les modules via un proxy de modules privé (par exemple Athens, Artifactory ou un endpoint GOPROXY).
>
> > [accordion] Secrets requis
> >
> > * `GO_PROXY_URL` — URL de votre proxy de modules Go (par exemple `https://athens.corp.internal`)
>
> Connectez le Git provider et accordez l'accès aux dépôts qui hébergent vos modules privés via les [Git integrations](https://docs.devin.ai/fr/integrations/overview.md). Utilisez des URL Git HTTPS classiques avec l'authentification configurée de Devin. N'intégrez pas de token dans une réécriture d'URL Git.
>
> ```yaml theme={null}
> initialize:
>   - name: Install Go
>     run: |
>       GO_VERSION=1.23.5
>       ARCH=$(dpkg --print-architecture)
>       curl -fsSL "https://go.dev/dl/go${GO_VERSION}.linux-${ARCH}.tar.gz" \
>         | sudo tar -xz -C /usr/local
>       echo 'export PATH="/usr/local/go/bin:$HOME/go/bin:$PATH"' \
>         | sudo tee /etc/profile.d/golang.sh > /dev/null
>
>   - name: Configure Go for private modules
>     run: |
>       cat << 'GOENV' | sudo tee /etc/profile.d/go-private.sh > /dev/null
>       export GOPROXY="$GO_PROXY_URL,direct"
>       export GONOSUMCHECK="corp.internal/*,github.com/myorg/*"
>       export GOPRIVATE="corp.internal/*,github.com/myorg/*"
>       GOENV
>
> knowledge:
>   - name: private_go_modules
>     contents: |
>       From the repository root, with GO_PROXY_URL available, run:
>         source /etc/profile.d/go-private.sh && go mod download
> ```
>
> Pour préremplir le cache des modules pendant les builds, ajoutez cette commande à la section `maintenance` du blueprint du **repository**, où `go.mod` est disponible. Ne l'exécutez pas dans le setup à l'échelle de l'organisation, qui s'exécute avant le clonage des repositories.
>
> > [!TIP]
> >
> > Formats d'URL de proxy Go courants :
> >
> > * **Artifactory :** `https://artifactory.example.com/artifactory/go-virtual`
> > * **Nexus :** `https://nexus.example.com/repository/go-proxy`
> > * **Athens :** `https://athens.corp.internal`

> [accordion] .NET / NuGet
>
> Configurez NuGet pour résoudre les packages depuis un flux privé.
>
> > [accordion] Secrets requis
> >
> > * `NUGET_SOURCE_URL` — URL de votre flux NuGet
> > * `NuGetPackageSourceCredentials_private` — Credentials du flux au format d'environnement NuGet : `Username=any;Password=<PAT>` (utilisez le username requis par votre flux)
>
> ```yaml theme={null}
> initialize:
>   - name: Install .NET SDK
>     run: |
>       curl -fsSL https://dot.net/v1/dotnet-install.sh | bash -s -- --channel 8.0
>       echo 'export PATH="$HOME/.dotnet:$PATH"' \
>         | sudo tee /etc/profile.d/dotnet.sh > /dev/null
>
> maintenance:
>   - name: Configure NuGet for private feed
>     run: |
>       dotnet nuget add source "$NUGET_SOURCE_URL" \
>         --name private 2>/dev/null || \
>       dotnet nuget update source private \
>         --source "$NUGET_SOURCE_URL"
>
> knowledge:
>   - name: private_nuget_packages
>     contents: |
>       Run dotnet restore with NuGetPackageSourceCredentials_private in its
>       environment. The suffix must match the source name "private".
> ```

> [accordion] Docker
>
> Configurez Docker pour récupérer les images depuis un registre de conteneurs privé.
>
> La commande docker login peut écrire les credentials dans son répertoire de configuration. Utilisez un répertoire isolé pour chaque opération et supprimez-le, même si le pull échoue. Réexécutez la séquence de connexion et de pull lorsque vous avez besoin d'une autre image au cours d'une session.
>
> > [accordion] Secrets requis
> >
> > * `DOCKER_MIRROR_URL` *(optionnel)* — URL de votre miroir Docker Hub (par ex., `https://mirror.corp.internal`)
> > * `DOCKER_REGISTRY_URL` — URL de votre registre de conteneurs privé (par ex., `registry.corp.internal:5000`)
> > * `DOCKER_REGISTRY_USER` — Nom d'utilisateur du registre
> > * `DOCKER_REGISTRY_PASS` — Mot de passe ou token d'API du registre
>
> ```yaml theme={null}
> initialize:
>   - name: Create Docker config directory
>     run: sudo mkdir -p /etc/docker
>
> maintenance:
>   - name: Configure Docker for private registry
>     run: |
>       # Configurer le mirror de registre (optionnel — achemine les pulls Docker Hub via votre registre)
>       cat << EOF | sudo tee /etc/docker/daemon.json > /dev/null
>       {
>         "registry-mirrors": ["$DOCKER_MIRROR_URL"]
>       }
>       EOF
>       sudo systemctl restart docker || true
>
> knowledge:
>   - name: private_container_images
>     contents: |
>       With the registry secrets available, run this in one shell.
>       Replace team/image:tag with the image to pull:
>         (
>           set -euo pipefail
>           umask 077
>           DOCKER_CONFIG=$(mktemp -d)
>           export DOCKER_CONFIG
>           trap 'rm -rf "$DOCKER_CONFIG"' EXIT
>           printf '%s' "$DOCKER_REGISTRY_PASS" |
>             docker login "$DOCKER_REGISTRY_URL" \
>               --username "$DOCKER_REGISTRY_USER" --password-stdin
>           docker pull "$DOCKER_REGISTRY_URL/team/image:tag"
>         )
> ```
>
> Pour mettre en cache une image dans le snapshot, placez ce même sous-shell complet dans une étape de build. Ne répartissez pas la connexion et le nettoyage sur plusieurs étapes, et vérifiez que le nettoyage aboutit avant la création de l'image. L'URL d'un mirror de registre ne doit pas contenir de credentials.
>
> > [!TIP]
> >
> > URLs de container registry courantes :
> >
> > * **Amazon ECR :** `<account-id>.dkr.ecr.<region>.amazonaws.com`
> > * **Azure Container Registry :** `<name>.azurecr.io`
> > * **Google Artifact Registry :** `<region>-docker.pkg.dev`
> > * **GitHub Container Registry :** `ghcr.io`
> > * **GitLab Container Registry :** `registry.gitlab.example.com`
> > * **Nexus :** `https://nexus.example.com:8443`
> > * **JFrog :** `<name>.jfrog.io`

> [accordion] Rust / Cargo
>
> Configurez Cargo pour résoudre les crates depuis un registre privé.
>
> > [!NOTE]
> >
> > **Rust** (via rustup) et **Cargo** sont **préinstallés** sur l'image de base de Devin. Passez l'étape d'installation si la chaîne d'outils stable par défaut suffit. Seule la configuration du registre est nécessaire.
>
> > [accordion] Secrets requis
> >
> > * `CARGO_REGISTRY_INDEX` — URL de l'index du registre privé (par ex. `sparse+https://cargo.corp.internal/api/v1/crates/`)
> > * `CARGO_REGISTRIES_PRIVATE_TOKEN` — Jeton d'authentification pour le registre nommé `private`
>
> ```yaml theme={null}
> initialize:
>   - name: Install Rust
>     run: |
>       curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs \
>         | sh -s -- -y --default-toolchain stable
>       echo 'source "$HOME/.cargo/env"' \
>         | sudo tee /etc/profile.d/rust.sh > /dev/null
>
> maintenance:
>   - name: Configure Cargo for private registry
>     run: |
>       mkdir -p ~/.cargo
>       cat > ~/.cargo/config.toml << EOF
>       [registry]
>       global-credential-providers = ["cargo:token"]
>
>       [registries.private]
>       index = "$CARGO_REGISTRY_INDEX"
>
>       [source.crates-io]
>       replace-with = "private"
>
>       [source.private]
>       registry = "$CARGO_REGISTRY_INDEX"
>       EOF
>
> knowledge:
>   - name: private_rust_packages
>     contents: |
>       Run cargo fetch with CARGO_REGISTRIES_PRIVATE_TOKEN in its environment.
> ```
>
> L'URL de l'index du registre ne doit pas contenir de credentials. Le provider `cargo:token` de Cargo lit le token du registre nommé depuis l'environnement ; n'exécutez pas `cargo login` dans une étape de build.
>
> > [!TIP]
> >
> > Si vous souhaitez simplement **ajouter** un registre privé sans remplacer crates.io, supprimez les sections `[source.crates-io]` et `[source.private]` et utilisez `cargo install --registry private` ou `[dependencies] my-crate = { version = "1.0", registry = "private" }` dans `Cargo.toml`.

> [accordion] Ruby / Bundler
>
> Installez Ruby et configurez Bundler pour résoudre les gems depuis un serveur de gems privé.
>
> > [accordion] Secrets requis
> >
> > * `GEM_SERVER_URL` — URL de votre serveur de gems privé (par exemple, `https://artifactory.example.com/artifactory/api/gems/gems-virtual`)
> > * `BUNDLE_ARTIFACTORY__EXAMPLE__COM` — `username:password` pour `artifactory.example.com` ; adaptez le nom de la variable à votre serveur de gems
>
> ```yaml theme={null}
> initialize:
>   - name: Install Ruby
>     run: |
>       sudo apt-get update -qq
>       sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq ruby-full
>
> maintenance:
>   - name: Configure Bundler for private gem server
>     run: |
>       bundle config set mirror.https://rubygems.org "$GEM_SERVER_URL"
>
> knowledge:
>   - name: private_ruby_packages
>     contents: |
>       Run bundle install with BUNDLE_ARTIFACTORY__EXAMPLE__COM in its environment.
> ```
>
> Utilisez un `GEM_SERVER_URL` sans credential. Pour la variable de credential de Bundler, préfixez le hostname en majuscules par `BUNDLE_`, remplacez chaque point par `__` et chaque tiret par `___`.
>
> > [!TIP]
> >
> > Patterns d'URL de gem server courants :
> >
> > * **Artifactory :** `https://artifactory.example.com/artifactory/api/gems/gems-virtual`
> > * **Nexus :** `https://nexus.example.com/repository/rubygems-proxy`
> > * **Gemfury :** `https://gem.fury.io/<org>`

> [accordion] PHP / Composer
>
> Installez PHP et configurez Composer pour résoudre les packages depuis un registre Packagist ou Satis privé.
>
> > [accordion] Secrets requis
> >
> > * `COMPOSER_REGISTRY_URL` — URL de votre registre Composer privé (par exemple `https://repo.packagist.com/<org>`)
> > * `COMPOSER_AUTH` — credentials JSON pour l'hôte du registre, par exemple `{"http-basic":{"repo.packagist.com":{"username":"<user>","password":"<token>"}}}`
>
> ```yaml theme={null}
> initialize:
>   - name: Install PHP and Composer
>     run: |
>       sudo apt-get update -qq
>       sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq \
>         php-cli php-mbstring php-xml php-curl unzip
>
>       # Installer Composer
>       curl -sS https://getcomposer.org/installer | php
>       sudo mv composer.phar /usr/local/bin/composer
>
> maintenance:
>   - name: Configure Composer for private registry
>     run: |
>       composer config --global repositories.private \
>         composer "$COMPOSER_REGISTRY_URL"
>
> knowledge:
>   - name: private_php_packages
>     contents: |
>       Run composer install with COMPOSER_AUTH in its environment.
>       Do not save these credentials to auth.json.
> ```
>
> Utilisez un `COMPOSER_REGISTRY_URL` sans credential.
>
> > [!TIP]
> >
> > Formats d'URL courants pour un registre Composer :
> >
> > * **Artifactory :** `https://artifactory.example.com/artifactory/api/composer/packagist-virtual`
> > * **Nexus :** `https://nexus.example.com/repository/packagist-proxy`
> > * **Private Packagist :** `https://repo.packagist.com/<org>`
> > * **Satis :** `https://satis.corp.internal`

> [accordion] Renouvellement du jeton AWS CodeArtifact
>
> Les tokens AWS CodeArtifact expirent normalement au bout de 12 heures. Créez un script contenant des références littérales, puis sourcez-le explicitement dans la même commande shell que npm, pip ou Maven pour obtenir un token. Enregistrer le script dans un blueprint ne suffit pas à l'exécuter au démarrage de la session.
>
> > [!NOTE]
> >
> > **`awscli` est préinstallé** sur l'image de base de Devin. Seuls le rafraîchissement du token et la configuration du registre restent à votre charge.
>
> > [accordion] Secrets requis
> >
> > * `AWS_ACCESS_KEY_ID` et `AWS_SECRET_ACCESS_KEY` — credentials IAM disposant des autorisations `codeartifact:GetAuthorizationToken` et `sts:GetServiceBearerToken`
> > * `CA_DOMAIN` — Le nom de votre domaine CodeArtifact
> > * `CA_DOMAIN_OWNER` — ID de l'AWS account propriétaire du domaine
> > * `CA_REGION` — Région AWS (par ex. `us-east-1`)
> > * `CA_NPM_REPO`, `CA_PYPI_REPO`, `CA_MAVEN_REPO` — Noms des repositories pour chaque écosystème
>
> ```yaml theme={null}
> maintenance:
>   - name: Configure CodeArtifact clients and refresh script
>     run: |
>       mkdir -p ~/.config
>       cat > ~/.config/codeartifact.sh <<'SCRIPT'
>       CODEARTIFACT_AUTH_TOKEN=$(aws codeartifact get-authorization-token \
>         --domain "$CA_DOMAIN" \
>         --domain-owner "$CA_DOMAIN_OWNER" \
>         --region "$CA_REGION" \
>         --query authorizationToken \
>         --output text) || return
>       export CODEARTIFACT_AUTH_TOKEN
>       export CA_ENDPOINT="https://${CA_DOMAIN}-${CA_DOMAIN_OWNER}.d.codeartifact.${CA_REGION}.amazonaws.com"
>       export PIP_INDEX_URL="https://aws:${CODEARTIFACT_AUTH_TOKEN}@${CA_DOMAIN}-${CA_DOMAIN_OWNER}.d.codeartifact.${CA_REGION}.amazonaws.com/pypi/${CA_PYPI_REPO}/simple/"
>       SCRIPT
>
>       # Configurer npm
>       npm config set registry '${CA_ENDPOINT}/npm/${CA_NPM_REPO}/'
>       npm config set "//${CA_DOMAIN}-${CA_DOMAIN_OWNER}.d.codeartifact.${CA_REGION}.amazonaws.com/npm/${CA_NPM_REPO}/:_authToken" '${CODEARTIFACT_AUTH_TOKEN}'
>
>       # Configurer Maven (facultatif)
>       mkdir -p ~/.m2
>       cat > ~/.m2/settings.xml <<'EOF'
>       <settings>
>         <servers>
>           <server>
>             <id>codeartifact</id>
>             <username>aws</username>
>             <password>${env.CODEARTIFACT_AUTH_TOKEN}</password>
>           </server>
>         </servers>
>         <mirrors>
>           <mirror>
>             <id>codeartifact</id>
>             <mirrorOf>*</mirrorOf>
>             <url>${env.CA_ENDPOINT}/maven/${env.CA_MAVEN_REPO}/</url>
>           </mirror>
>         </mirrors>
>       </settings>
>       EOF
>
> knowledge:
>   - name: codeartifact_packages
>     contents: |
>       With AWS credentials and the CA_* variables available, run the appropriate
>       command in one shell; source the script again for later invocations:
>         source ~/.config/codeartifact.sh && npm install
>         source ~/.config/codeartifact.sh && pip install -r requirements.txt
>         source ~/.config/codeartifact.sh && mvn dependency:resolve
> ```
>
> Pour préchauffer un cache de dépendances dans le snapshot, ajoutez la commande `source ... &&` appropriée en tant qu'étape de build ultérieure. Le token récupéré reste dans l'environnement de ce shell : ne le rendez pas persistant via `aws codeartifact login`, via `npm config set` avec un token développé, ni via un fichier `pip.conf` contenant des credentials.

***

## Infrastructure Enterprise

Infrastructure au niveau des machines qui s’applique à l’ensemble des organisations et des repos. Définissez ces paramètres dans **Enterprise Settings > Environments > Blueprint** (à l’échelle de l’entreprise) ou **Settings > environnement > Blueprints > configuration à l’échelle de l’organisation** (à l’échelle de l’organisation).

### Réseau et connectivité

> [accordion] Certificat d’autorité de certification interne
>
> Votre organisation utilise une autorité de certification privée pour ses services internes. Devin a besoin du certificat racine pour accéder aux dépôts et outils internes via HTTPS.
>
> > [accordion] Secrets requis
> >
> > * `CORP_ROOT_CA_B64` — certificat PEM encodé en Base64 issu de votre autorité de certification d’entreprise. Générez-le avec : `cat corp-root-ca.crt | base64 -w0`
>
> ```yaml theme={null}
> initialize:
>   - name: Install corporate CA certificate
>     run: |
>       set -o pipefail
>       printf '%s' "$CORP_ROOT_CA_B64" | base64 -d | openssl x509 -outform PEM \
>         | sudo tee /usr/local/share/ca-certificates/corp-root-ca.crt > /dev/null
>       sudo update-ca-certificates
>       echo 'export NODE_EXTRA_CA_CERTS=/usr/local/share/ca-certificates/corp-root-ca.crt' \
>         | sudo tee /etc/profile.d/node-ca.sh > /dev/null
> ```
>
> Ces entrées sont des certificats publics. `openssl x509` n’écrit que le certificat analysé : une clé privée incluse par inadvertance n’est donc pas copiée dans le magasin de certificats de confiance. Fournissez chaque certificat d’autorité de certification séparément, comme dans l’exemple suivant.

> [accordion] Plusieurs certificats d’autorité de certification
>
> Si votre organisation utilise plusieurs certificats d’autorité de certification (par exemple, des autorités de certification distinctes pour différents services internes).
>
> > [accordion] Secrets requis
> >
> > * `CORP_ROOT_CA_B64` — certificat principal d’autorité de certification encodé en Base64
> > * `CORP_INTERMEDIATE_CA_B64` — certificat intermédiaire d’autorité de certification encodé en Base64
>
> ```yaml theme={null}
> initialize:
>   - name: Install corporate CA certificates
>     run: |
>       set -o pipefail
>       printf '%s' "$CORP_ROOT_CA_B64" | base64 -d | openssl x509 -outform PEM \
>         | sudo tee /usr/local/share/ca-certificates/corp-root-ca.crt > /dev/null
>       printf '%s' "$CORP_INTERMEDIATE_CA_B64" | base64 -d | openssl x509 -outform PEM \
>         | sudo tee /usr/local/share/ca-certificates/corp-intermediate-ca.crt > /dev/null
>       sudo update-ca-certificates
>
>       # Créer un bundle combiné pour les outils nécessitant un seul fichier CA
>       cat /usr/local/share/ca-certificates/corp-*.crt \
>         | sudo tee /usr/local/share/ca-certificates/corp-bundle.crt > /dev/null
>
>       echo 'export NODE_EXTRA_CA_CERTS=/usr/local/share/ca-certificates/corp-bundle.crt' \
>         | sudo tee /etc/profile.d/node-ca.sh > /dev/null
> ```

> [accordion] Proxy HTTP/HTTPS
>
> Faites passer tout le trafic réseau par un proxy d’entreprise.
>
> > [accordion] Secrets requis
> >
> > * `CORP_HTTP_PROXY` — URL du proxy HTTP (p. ex., `http://proxy.corp.example.com:8080`)
> > * `CORP_HTTPS_PROXY` — URL du proxy HTTPS
> > * `CORP_NO_PROXY` — liste d’hôtes, séparés par des virgules, à ne pas faire passer par le proxy (p. ex., `localhost,127.0.0.1,.corp.example.com`)
>
> ```yaml theme={null}
> initialize:
>   - name: Configure system-wide proxy
>     run: |
>       cat << 'PROXY' | sudo tee /etc/profile.d/proxy.sh > /dev/null
>       export http_proxy="$CORP_HTTP_PROXY"
>       export https_proxy="$CORP_HTTPS_PROXY"
>       export no_proxy="$CORP_NO_PROXY"
>       export HTTP_PROXY="$CORP_HTTP_PROXY"
>       export HTTPS_PROXY="$CORP_HTTPS_PROXY"
>       export NO_PROXY="$CORP_NO_PROXY"
>       PROXY
>       source /etc/profile.d/proxy.sh
>
> knowledge:
>   - name: proxy_commands
>     contents: |
>       With CORP_HTTP_PROXY, CORP_HTTPS_PROXY and CORP_NO_PROXY available, source
>       the proxy setup in each command that needs it, for example:
>         source /etc/profile.d/proxy.sh && npm install
>         source /etc/profile.d/proxy.sh && git fetch
> ```

> [accordion] Proxy authentifié
>
> Si votre proxy d’entreprise nécessite une authentification par nom d’utilisateur et mot de passe.
>
> > [accordion] Secrets requis
> >
> > * `PROXY_USER` — Nom d’utilisateur du proxy
> > * `PROXY_PASS` — Mot de passe du proxy
> > * `PROXY_HOST` — Nom d’hôte et port du proxy (par ex., `proxy.corp.example.com:8080`)
> > * `CORP_NO_PROXY` — Hôtes à exclure du proxy
>
> ```yaml theme={null}
> initialize:
>   - name: Configure authenticated proxy
>     run: |
>       cat <<'PROXY' | sudo tee /etc/profile.d/proxy.sh > /dev/null
>       export http_proxy="http://${PROXY_USER}:${PROXY_PASS}@${PROXY_HOST}"
>       export https_proxy="$http_proxy"
>       export no_proxy="$CORP_NO_PROXY"
>       export HTTP_PROXY="$http_proxy"
>       export HTTPS_PROXY="$https_proxy"
>       export NO_PROXY="$CORP_NO_PROXY"
>       PROXY
>       source /etc/profile.d/proxy.sh
>
> knowledge:
>   - name: authenticated_proxy_commands
>     contents: |
>       With the proxy secrets available, source the proxy setup in the same
>       command as each tool that needs it, for example:
>         source /etc/profile.d/proxy.sh && git fetch
> ```
>
> Encodez en pourcentage les caractères spéciaux du nom d’utilisateur et du mot de passe du proxy. Git et npm peuvent utiliser les variables d’environnement de proxy ; ne copiez pas une URL de proxy contenant des identifiants dans leur configuration persistante.

> [accordion] certificat d’autorité de certification + proxy (combinés)
>
> Configuration combinée pour les environnements nécessitant à la fois une autorité de certification d’entreprise et un proxy. Ce cas est fréquent dans les environnements d’entreprise où les services internes utilisent des certificats privés et où tout le trafic doit transiter par un proxy.
>
> > [accordion] Secrets requis
> >
> > * `CORP_ROOT_CA_B64` — certificat d’autorité de certification d’entreprise encodé en Base64
> > * `CORP_HTTP_PROXY`, `CORP_HTTPS_PROXY` — URL du proxy
> > * `CORP_NO_PROXY` — hôtes à exclure du proxy
>
> ```yaml theme={null}
> initialize:
>   - name: Install corporate CA certificate
>     run: |
>       set -o pipefail
>       printf '%s' "$CORP_ROOT_CA_B64" | base64 -d | openssl x509 -outform PEM \
>         | sudo tee /usr/local/share/ca-certificates/corp-root-ca.crt > /dev/null
>       sudo update-ca-certificates
>       echo 'export NODE_EXTRA_CA_CERTS=/usr/local/share/ca-certificates/corp-root-ca.crt' \
>         | sudo tee /etc/profile.d/node-ca.sh > /dev/null
>
>   - name: Configure system-wide proxy
>     run: |
>       cat << 'PROXY' | sudo tee /etc/profile.d/proxy.sh > /dev/null
>       export http_proxy="$CORP_HTTP_PROXY"
>       export https_proxy="$CORP_HTTPS_PROXY"
>       export no_proxy="$CORP_NO_PROXY"
>       export HTTP_PROXY="$CORP_HTTP_PROXY"
>       export HTTPS_PROXY="$CORP_HTTPS_PROXY"
>       export NO_PROXY="$CORP_NO_PROXY"
>       PROXY
>       source /etc/profile.d/proxy.sh
>
> knowledge:
>   - name: proxy_commands
>     contents: |
>       With the proxy secrets available, run:
>         source /etc/profile.d/proxy.sh && git fetch
> ```

> [accordion] Connexion au VPN
>
> Vos registres privés, serveurs Git ou autres services internes ne sont accessibles que via un VPN. Installez le client VPN dans le blueprint. Établissez explicitement le tunnel pour les opérations qui en ont besoin, puis déconnectez-vous et supprimez les fichiers d’identifiants.
>
> > [accordion] Secrets requis
> >
> > **OpenVPN :**
> >
> > * `VPN_CONFIG_B64` — Fichier de configuration OpenVPN encodé en Base64 (`.ovpn`). Générez-le avec : `cat corp.ovpn | base64 -w0`
> > * `VPN_AUTH_USER` *(facultatif)* — Nom d’utilisateur du VPN, si votre VPN nécessite une authentification par nom d’utilisateur et mot de passe
> > * `VPN_AUTH_PASS` *(facultatif)* — Mot de passe du VPN
> >
> > **WireGuard :**
> >
> > * `WG_CONFIG_B64` — Fichier de configuration WireGuard encodé en Base64. Générez-le avec : `cat wg0.conf | base64 -w0`
>
> **OpenVPN :**
>
> ```yaml theme={null}
> initialize:
>   - name: Install OpenVPN
>     run: |
>       sudo DEBIAN_FRONTEND=noninteractive apt-get update -qq
>       sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq openvpn
> ```
>
> Exécutez ce block explicitement dans une session où les secrets du VPN sont disponibles. Remplacez la commande `curl` par le travail qui nécessite le tunnel. La configuration doit contenir en ligne les certificats et clés requis et utiliser `dev tun0` ; n'activez pas de service VPN persistant.
>
> ```bash theme={null}
> (
>   set -euo pipefail
>   umask 077
>   VPN_DIR=$(mktemp -d)
>   cleanup() {
>     if [ -f "$VPN_DIR/openvpn.pid" ]; then
>       sudo kill "$(cat "$VPN_DIR/openvpn.pid")" || true
>     fi
>     sudo rm -rf "$VPN_DIR"
>   }
>   trap cleanup EXIT
>   printf '%s' "$VPN_CONFIG_B64" | base64 -d > "$VPN_DIR/corp.conf"
>   if [ -n "${VPN_AUTH_USER:-}" ] && [ -n "${VPN_AUTH_PASS:-}" ]; then
>     printf '%s\n%s\n' "$VPN_AUTH_USER" "$VPN_AUTH_PASS" > "$VPN_DIR/auth.txt"
>     printf 'auth-user-pass %s/auth.txt\n' "$VPN_DIR" >> "$VPN_DIR/corp.conf"
>   fi
>   sudo openvpn --config "$VPN_DIR/corp.conf" \
>     --writepid "$VPN_DIR/openvpn.pid" --daemon
>   for i in $(seq 1 30); do
>     if ip link show tun0 >/dev/null 2>&1; then break; fi
>     sleep 1
>   done
>   ip link show tun0 >/dev/null
>   curl --fail https://service.corp.internal/health
> )
> ```
>
> **WireGuard :**
>
> ```yaml theme={null}
> initialize:
>   - name: Install WireGuard
>     run: |
>       sudo DEBIAN_FRONTEND=noninteractive apt-get update -qq
>       sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq wireguard-tools
> ```
>
> Exécutez ce block explicitement avec `WG_CONFIG_B64` disponible, en remplaçant la commande `curl` par votre opération :
>
> ```bash theme={null}
> (
>   set -euo pipefail
>   umask 077
>   VPN_DIR=$(mktemp -d)
>   cleanup() {
>     sudo wg-quick down "$VPN_DIR/corp.conf" || true
>     sudo rm -rf "$VPN_DIR"
>   }
>   trap cleanup EXIT
>   printf '%s' "$WG_CONFIG_B64" | base64 -d > "$VPN_DIR/corp.conf"
>   sudo wg-quick up "$VPN_DIR/corp.conf"
>   curl --fail https://service.corp.internal/health
> )
> ```
>
> Si un build du snapshot nécessite un accès VPN, regroupez **tout** le travail dépendant dans le même block afin que le nettoyage soit terminé avant la création de l’image. Déplacer simplement l’écriture des credentials vers `maintenance` ne les rend pas temporaires. Ne créez pas de snapshot d’un tunnel actif ou d’une configuration VPN privée.
>
> > [!TIP]
> >
> > Pour plus d'informations sur la configuration du VPN, consultez [Configuration du VPN](https://docs.devin.ai/fr/onboard-devin/vpn.md).

> [accordion] Résolution DNS personnalisée
>
> Vos services internes utilisent des noms DNS privés qui ne sont pas résolubles via le DNS public.
>
> ```yaml theme={null}
> initialize:
>   - name: Configure custom DNS resolution
>     run: |
>       # Ajouter les noms d'hôtes internes
>       cat << 'HOSTS' | sudo tee -a /etc/hosts > /dev/null
>       10.0.1.50  nexus.corp.internal
>       10.0.1.51  git.corp.internal
>       10.0.1.52  artifactory.corp.internal
>       HOSTS
>
>       # Configurer éventuellement des serveurs de noms personnalisés
>       sudo mkdir -p /etc/systemd/resolved.conf.d
>       cat << 'DNS' | sudo tee /etc/systemd/resolved.conf.d/corp.conf > /dev/null
>       [Resolve]
>       DNS=10.0.0.53 10.0.0.54
>       Domains=corp.internal
>       DNS
>       sudo systemctl restart systemd-resolved || true
> ```

### Identité et sécurité

> [accordion] Signature GPG des commits
>
> Votre organisation exige que tous les commits Git soient signés et vous souhaitez que GitHub marque les commits de Devin comme **Verified**.
>
> > [accordion] Secrets requis
> >
> > * `GPG_PRIVATE_KEY_B64` — clé privée GPG encodée en Base64. À générer avec : `gpg --export-secret-keys <key-id> | base64 -w0`
> > * `GPG_SIGNING_KEY` — empreinte complète de la clé de signature
> > * `GIT_USER_NAME` — nom de l'auteur Git (par exemple, `Devin AI`)
> > * `GIT_USER_EMAIL` — adresse e-mail de l'auteur Git. **Doit correspondre à un UID de la clé GPG**, faute de quoi GitHub ne vérifiera pas la signature.
>
> > [!NOTE]
> >
> > Téléversez également la clé **publique** correspondante sur le GitHub account dont Devin utilise les credentials pour pousser ses commits (dans [GitHub Settings > SSH and GPG keys](https://github.com/settings/keys)). GitHub ne marque les commits comme Verified que si la clé publique de signature est enregistrée sur le compte auteur du commit.
>
> N'importez pas de clés de signature privées pendant les builds de snapshots. Une fois les modifications voulues mises en staging, exécutez explicitement ce bloc dans une session où les secrets nommés sont disponibles. Il s'appuie sur un porte-clés temporaire et des paramètres Git valables uniquement pour ce commit :
>
> ```bash theme={null}
> (
>   set -euo pipefail
>   umask 077
>   GNUPGHOME=$(mktemp -d)
>   export GNUPGHOME
>   trap 'gpgconf --kill gpg-agent; rm -rf "$GNUPGHOME"' EXIT
>   printf '%s' "$GPG_PRIVATE_KEY_B64" | base64 -d | gpg --batch --import
>   git -c user.name="$GIT_USER_NAME" -c user.email="$GIT_USER_EMAIL" \
>     -c user.signingkey="$GPG_SIGNING_KEY" -c commit.gpgsign=true \
>     -c gpg.program=gpg commit -m "Describe the change"
> )
> ```
>
> Si votre clé nécessite une phrase secrète, déroulez le flux GPG agent/pinentry approuvé pendant l'opération. N'enregistrez ni la phrase secrète ni le porte-clés dans le blueprint ou le snapshot. Reproduisez la configuration du porte-clés temporaire pour les commits ultérieurs ou les balises signées.

> [accordion] Identité Git et clés SSH
>
> Configurez l'identité Git et les clés SSH de Devin pour accéder à des serveurs Git privés.
>
> Privilégiez les [Git integrations](https://docs.devin.ai/fr/integrations/overview.md) pour les Git providers pris en charge. Pour un serveur qui exige une clé SSH explicite, gardez la clé privée hors du build du blueprint et utilisez-la uniquement pour l'opération de session décrite ci-dessous.
>
> > [accordion] Secrets requis
> >
> > * `GIT_USER_NAME` — nom de l'auteur Git
> > * `GIT_USER_EMAIL` — adresse e-mail de l'auteur Git
> > * `SSH_PRIVATE_KEY_B64` — clé privée SSH encodée en Base64. À générer avec : `cat ~/.ssh/id_ed25519 | base64 -w0`
> > * `SSH_KNOWN_HOSTS_B64` — entrées known hosts encodées en Base64, vérifiées par rapport aux empreintes de clés d'hôte publiées par l'administrateur de votre serveur
>
> ```yaml theme={null}
> initialize:
>   - name: Configure git identity
>     run: |
>       git config --global user.name "$GIT_USER_NAME"
>       git config --global user.email "$GIT_USER_EMAIL"
> ```
>
> Exécutez explicitement ce bloc dans la session, en remplaçant l'URL Git par celle de votre serveur et de votre repository :
>
> ```bash theme={null}
> (
>   set -euo pipefail
>   umask 077
>   SSH_DIR=$(mktemp -d)
>   trap 'rm -rf "$SSH_DIR"' EXIT
>   printf '%s' "$SSH_PRIVATE_KEY_B64" | base64 -d > "$SSH_DIR/id_ed25519"
>   printf '%s' "$SSH_KNOWN_HOSTS_B64" | base64 -d > "$SSH_DIR/known_hosts"
>   export GIT_SSH_COMMAND="ssh -F /dev/null -i '$SSH_DIR/id_ed25519' -o IdentitiesOnly=yes -o UserKnownHostsFile='$SSH_DIR/known_hosts' -o StrictHostKeyChecking=yes"
>   git ls-remote git@git.corp.internal:team/repo.git
> )
> ```
>
> > [!TIP]
> >
> > Si vous avez besoin d'options SSH personnalisées, ajoutez-les à cette invocation sans copier de clé privée dans un fichier de configuration SSH persistant ou dans le home directory. Reproduisez cette configuration à chaque opération.

### Configuration du système

> [accordion] Packages du système
>
> Installez les packages système qui ne figurent pas dans l’image Devin par défaut (p. ex., des bibliothèques natives pour le traitement d’images ou la génération de PDF).
>
> ```yaml theme={null}
> initialize:
>   - name: Install system packages
>     run: |
>       sudo apt-get update -qq
>       sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq \
>         libpq-dev \
>         libmagickwand-dev \
>         poppler-utils \
>         ffmpeg
> ```

> [accordion] Variables d’environnement personnalisées
>
> Définissez des variables d’environnement persistantes et non secrètes qui doivent être disponibles dans chaque session. N’écrivez pas de valeurs secrètes ni de credentials dérivés dans `$ENVRC`.
>
> L’approche recommandée consiste à écrire des lignes `KEY=VALUE` dans le fichier `$ENVRC`. Les variables écrites dans `$ENVRC` sont automatiquement exportées pour toutes les étapes suivantes ainsi que pour la session Devin (comme avec le `$GITHUB_ENV` de GitHub Actions).
>
> ```yaml theme={null}
> initialize:
>   - name: Set custom environment variables
>     run: |
>       echo "CORPORATE_ENV=production" >> $ENVRC
>       echo "DEFAULT_REGION=us-east-1" >> $ENVRC
>       echo "MAX_RETRIES=3" >> $ENVRC
> ```
>
> > [!TIP]
> >
> > Vous pouvez également définir des variables d’environnement dans des scripts `/etc/profile.d/` afin de les rendre disponibles à l’échelle du système :
> >
> > ```bash theme={null}
> > cat << 'ENVVARS' | sudo tee /etc/profile.d/custom-env.sh > /dev/null
> > export CORPORATE_ENV=production
> > export DEFAULT_REGION=us-east-1
> > ENVVARS
> > ```
> >
> > Les deux approches fonctionnent. `$ENVRC` est plus simple et recommandé dans la plupart des cas.

> [accordion] Paramètres régionaux et fuseau horaire
>
> Les images de base par défaut peuvent avoir des paramètres régionaux incorrects. Configurez les paramètres régionaux et le fuseau horaire pour éviter les avertissements des outils de build, de Java, de Python et de Git.
>
> ```yaml theme={null}
> initialize:
>   - name: Configure locale and timezone
>     run: |
>       sudo DEBIAN_FRONTEND=noninteractive apt-get update -qq
>       sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq locales
>
>       # Générer et définir la locale
>       sudo sed -i 's/^# *en_US.UTF-8/en_US.UTF-8/' /etc/locale.gen
>       sudo locale-gen
>       sudo update-locale LANG=en_US.UTF-8 LC_ALL=en_US.UTF-8
>
>       cat << 'LOCALE' | sudo tee /etc/profile.d/locale.sh > /dev/null
>       export LANG="en_US.UTF-8"
>       export LC_ALL="en_US.UTF-8"
>       LOCALE
>
>       # Définir le fuseau horaire
>       sudo timedatectl set-timezone UTC 2>/dev/null || \
>         sudo ln -sfn /usr/share/zoneinfo/UTC /etc/localtime
> ```

> [accordion] Limites de ressources (ulimits)
>
> Les builds Java, Gradle et Node.js atteignent fréquemment la limite par défaut de 1 024 fichiers ouverts. Augmentez-la pour éviter les build failures.
>
> ```yaml theme={null}
> initialize:
>   - name: Raise resource limits
>     run: |
>       cat << 'LIMITS' | sudo tee /etc/security/limits.d/99-devin.conf > /dev/null
>       *    soft    nofile    65536
>       *    hard    nofile    65536
>       *    soft    nproc     65536
>       *    hard    nproc     65536
>       LIMITS
>
>       # Définir aussi le maximum du noyau
>       echo "fs.file-max = 65536" | sudo tee /etc/sysctl.d/99-devin-filemax.conf > /dev/null
>       sudo sysctl -p /etc/sysctl.d/99-devin-filemax.conf 2>/dev/null || true
> ```

> [accordion] Remplacement du miroir APT
>
> Dans les environnements en air gap ou restreints, remplacez les sources APT Ubuntu par défaut par un miroir interne.
>
> > [accordion] Secrets requis
> >
> > * `APT_MIRROR_URL` — URL de votre miroir APT interne (p. ex., `https://artifactory.example.com/artifactory/ubuntu-remote`)
>
> ```yaml theme={null}
> initialize:
>   - name: Replace APT sources with internal mirror
>     run: |
>       # Sauvegarder les sources originales
>       sudo cp /etc/apt/sources.list /etc/apt/sources.list.bak
>
>       # Remplacer tous les miroirs Ubuntu par votre miroir interne
>       sudo sed -i "s|http://archive.ubuntu.com/ubuntu|$APT_MIRROR_URL|g" /etc/apt/sources.list
>       sudo sed -i "s|http://security.ubuntu.com/ubuntu|$APT_MIRROR_URL|g" /etc/apt/sources.list
>
>       sudo apt-get update -qq
> ```
>
> > [!TIP]
> >
> > Schémas d’URL courants pour les miroirs APT :
> >
> > * **Artifactory:** `https://artifactory.example.com/artifactory/ubuntu-remote`
> > * **Nexus:** `https://nexus.example.com/repository/ubuntu-proxy`

***

## Patterns avancés

> [accordion] Variables d’environnement avec direnv
>
> L’environnement de base de Devin comprend [direnv](https://direnv.net/). Utilisez `initialize` pour créer des fichiers `.envrc`. Direnv les charge automatiquement.
>
> ```yaml theme={null}
> initialize: |
>   cat <<'EOF' > .envrc
>   export DATABASE_URL=postgresql://localhost:5432/myapp_dev
>   export REDIS_URL=redis://localhost:6379
>   export APP_ENV=development
>   EOF
>
> maintenance: |
>   direnv allow .
> ```
>
> > [!NOTE]
> >
> > direnv est intégré d’emblée au shell de Devin, donc les variables `.envrc` se chargent automatiquement. Aucun chargement manuel n’est nécessaire.
>
> > [!TIP]
> >
> > Pour les variables d’environnement **sensibles** (API keys, jetons, mots de passe de base de données), utilisez les [secrets du dépôt](https://docs.devin.ai/fr/product-guides/secrets.md) plutôt que des fichiers `.envrc`, et liez-les explicitement aux commandes de session qui en ont besoin. Développer un secret dans un fichier pendant un build peut malgré tout l’inscrire dans le snapshot.

> [accordion] Sélection de la version de Node par dépôt
>
> Utilisez nvm (préinstallé) pour changer de version de Node.js pour chaque dépôt via `.nvmrc`.
>
> ```yaml theme={null}
> initialize: |
>   nvm install 18
>   nvm install 20
>   nvm install 22
>
> maintenance: |
>   nvm use
> ```
>
> > [!NOTE]
> >
> > `nvm use` lit `.nvmrc` à la racine du dépôt. Assurez-vous que votre dépôt en contient un (p. ex. avec `20`).

> [accordion] Authentification dans le navigateur (Playwright)
>
> Devin fournit un navigateur Chrome avec un endpoint CDP sur `localhost:29229` **pendant les sessions**. Utilisez des scripts Playwright pour automatiser la connexion via le navigateur.
>
> > [!WARNING]
> >
> > Le navigateur n'est disponible que pendant les sessions, pas dans les builds du snapshot. Installez Playwright dans `initialize` et conservez les scripts de connexion dans votre repo.
>
> ```yaml theme={null}
> initialize: |
>   pip install playwright
>   playwright install chromium
>
> maintenance: |
>   npm install
>
> knowledge:
>   - name: browser-auth
>     contents: |
>       This project requires browser authentication.
>       Run the login script before interacting with the app:
>       python scripts/login.py
>
>       Devin's Chrome browser is accessible via CDP at:
>       http://localhost:29229
> ```
>
> Exemple de script de connexion (`scripts/login.py`) :
>
> ```python theme={null}
> from playwright.sync_api import sync_playwright
> import os
>
> with sync_playwright() as p:
>     browser = p.chromium.connect_over_cdp("http://localhost:29229")
>     context = browser.contexts[0]
>     page = context.pages[0] if context.pages else context.new_page()
>
>     page.goto("https://internal-tool.example.com/login")
>     page.fill("#username", os.environ["TOOL_USERNAME"])
>     page.fill("#password", os.environ["TOOL_PASSWORD"])
>     page.click('button[type="submit"]')
>     page.wait_for_url("**/dashboard")
> ```
>
> > [!WARNING]
> >
> > Stockez les identifiants de connexion dans les secrets, pas dans le code source. Pour une authentification persistante, versionnez les scripts de connexion dans `.agents/skills/` afin que Devin puisse se réauthentifier automatiquement.

> [accordion] Outils système personnalisés et PATH
>
> Installez des packages système, des binaires personnalisés et configurez le PATH dans `initialize`.
>
> ```yaml theme={null}
> initialize:
>   - name: Install system packages
>     run: |
>       apt-get update
>       apt-get install -y \
>         jq \
>         ripgrep \
>         fd-find \
>         protobuf-compiler \
>         libssl-dev
>
>   - name: Install custom CLI tool
>     run: |
>       curl -L https://github.com/example/tool/releases/download/v1.0/tool-linux-amd64 \
>         -o /usr/local/bin/mytool
>       chmod +x /usr/local/bin/mytool
>
>   - name: Add custom bin directory to PATH
>     run: |
>       mkdir -p ~/bin
>       echo 'export PATH="$HOME/bin:$PATH"' >> ~/.bashrc
>
> knowledge:
>   - name: tools
>     contents: |
>       Custom tools available:
>       - mytool: installed at /usr/local/bin/mytool
>       - Additional binaries can be placed in ~/bin
> ```

> [accordion] GitHub Actions pour configurer l’outil
>
> Devin prend en charge l’exécution de GitHub Actions directement dans la section `initialize` d’un blueprint. Cela est utile pour installer des versions spécifiques d’outils via les mêmes actions que celles utilisées par votre CI.
>
> ```yaml theme={null}
> initialize:
>   - name: "Install Node.js 20"
>     uses: github.com/actions/setup-node@v4
>     with:
>       node-version: "20"
>
>   - name: "Install Python 3.12"
>     uses: github.com/actions/setup-python@v5
>     with:
>       python-version: "3.12"
>
>   - name: "Install Go 1.22"
>     uses: github.com/actions/setup-go@v5
>     with:
>       go-version: "1.22"
>
>   - name: "Install Java 21"
>     uses: github.com/actions/setup-java@v4
>     with:
>       java-version: "21"
>       distribution: "temurin"
>
>   - name: "Install Gradle"
>     uses: github.com/gradle/actions/setup-gradle@v4
>
>   - name: "Install Ruby 3.3"
>     uses: github.com/ruby/setup-ruby@v1
>     with:
>       ruby-version: "3.3"
>
>   - name: "Install additional tools"
>     run: |
>       pip install uv
>       npm install -g pnpm turbo
>       go install golang.org/x/tools/gopls@latest
>
> maintenance: |
>   echo "All runtimes are available:"
>   node --version
>   python --version
>   go version
>   java --version
> ```
>
> > [!NOTE]
> >
> > Des actions comme `setup-node` et `setup-python` modifient le PATH et les variables d’environnement. Les binaires installés par une action sont disponibles dans toutes les étapes suivantes et dans `maintenance`. Les actions Node.js et composites sont prises en charge ; les actions Docker ne le sont que sur les builds Linux. Les étapes `uses` ne peuvent pas s’exécuter dans `maintenance`. Voir [les limites des GitHub Actions](https://docs.devin.ai/fr/onboard-devin/environment/github-actions#limitations).
>
> > [!TIP]
> >
> > Vous n’avez pas besoin de GitHub Actions pour la configuration de base des outils. Des commandes shell directes (`nvm install 20`, `curl ... | sh`, `apt-get install`) fonctionnent tout aussi bien et sont souvent plus simples. Les GitHub Actions sont surtout utiles si vous voulez reproduire exactement votre configuration CI ou bénéficier de la praticité d’actions comme `setup-java`, qui gèrent plusieurs distributions.

> [accordion] Proxy inverse HTTPS en local pour plusieurs applications
>
> Exécutez plusieurs services derrière des noms d’hôte plausibles via HTTPS, comme `app.example.com`, `api.example.com` et `admin.example.com`. Installez un seul proxy inverse dans `initialize` et faites pointer chaque nom d’hôte vers un port upstream local distinct.
>
> [Caddy](https://caddyserver.com/) gère le routage et le TLS local dans un seul outil. Un Caddyfile associe chaque nom d’hôte à un upstream, et `tls internal` émet automatiquement, pour chaque nom d’hôte, un certificat approuvé à partir de l’autorité de certification intégrée à Caddy. `caddy trust` installe la racine de cette autorité dans le magasin de confiance du système, et l’ajout de cette même racine à la base de données NSS permet au navigateur de l’accepter.
>
> Importez votre Caddyfile via la section **Pièces jointes** de l’éditeur de blueprint ; il sera alors disponible sous la forme `$FILE_CADDYFILE`.
>
> ```caddyfile Caddyfile theme={null}
> app.example.com {
>   tls internal
>   reverse_proxy 127.0.0.1:3000
> }
>
> api.example.com {
>   tls internal
>   reverse_proxy 127.0.0.1:3001
> }
>
> admin.example.com {
>   tls internal
>   reverse_proxy 127.0.0.1:3002
> }
> ```
>
> ```yaml theme={null}
> initialize:
>   - name: Install Caddy and NSS tools
>     run: |
>       sudo apt-get install -y debian-keyring debian-archive-keyring \
>         apt-transport-https curl libnss3-tools
>       curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' \
>         | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
>       curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' \
>         | sudo tee /etc/apt/sources.list.d/caddy-stable.list
>       sudo apt-get update -qq
>       sudo apt-get install -y caddy
>
>   - name: Install Caddyfile, hosts entries, and trust internal CA
>     run: |
>       sudo install -m 0644 "$FILE_CADDYFILE" /etc/caddy/Caddyfile
>
>       for host in app.example.com api.example.com admin.example.com; do
>         grep -q " $host$" /etc/hosts \
>           || echo "127.0.0.1 $host" | sudo tee -a /etc/hosts > /dev/null
>       done
>
>       sudo systemctl enable --now caddy
>       sudo caddy trust
>
>       mkdir -p ~/.pki/nssdb
>       [ -f ~/.pki/nssdb/cert9.db ] \
>         || certutil -d sql:$HOME/.pki/nssdb -N --empty-password
>
>       CADDY_ROOT=/var/lib/caddy/.local/share/caddy/pki/authorities/local/root.crt
>       for _ in $(seq 1 30); do
>         sudo test -f "$CADDY_ROOT" && break
>         sleep 1
>       done
>
>       if sudo test -f "$CADDY_ROOT" \
>          && ! certutil -d sql:$HOME/.pki/nssdb -L | grep -q "Caddy Local Authority"; then
>         sudo install -o "$USER" -m 0644 "$CADDY_ROOT" /tmp/caddy-root.crt
>         certutil -d sql:$HOME/.pki/nssdb -A -t "C,," \
>           -n "Caddy Local Authority" -i /tmp/caddy-root.crt
>         rm -f /tmp/caddy-root.crt
>       fi
> ```
>
> > [!NOTE]
> >
> > Le bloc `/etc/hosts` permet à `app.example.com` de pointer vers `127.0.0.1` à l’intérieur de la session. Ajoutez une entrée pour chaque hostname que vous mettez dans le Caddyfile.
>
> > [!TIP]
> >
> > Pour ajouter un service, ajoutez un bloc de trois lignes au Caddyfile et une entrée au bloc `/etc/hosts`, puis accédez à son hostname en HTTPS. Caddy génère un certificat à la première requête ; aucune génération de certificat par application n’est donc nécessaire.

***

## Exemples full-stack

Ces exemples montrent comment les configurations Enterprise et celles au niveau de l'org se combinent. En pratique, vous les répartiriez entre plusieurs périmètres. Elles sont regroupées ici à titre de référence.

> [accordion] Stack complète pour entreprise (Artifactory)
>
> Un environnement d'entreprise complet : certificat d'autorité de certification d'entreprise, proxy, Java (Maven), Python (pip/uv), Node.js (npm) et Docker, le tout pointant vers une seule instance Artifactory.
>
> > [accordion] Secrets requis
> >
> > **Réseau & confiance (échelle du compte) :**
> >
> > * `CORP_ROOT_CA_B64` — certificat d’autorité de certification d’entreprise encodé en Base64
> > * `CORP_HTTP_PROXY` — URL du proxy HTTP
> > * `CORP_HTTPS_PROXY` — URL du proxy HTTPS
> > * `CORP_NO_PROXY` — hôtes à ne pas faire passer par le proxy
> >
> > **Identifiants du registre (échelle de l’organisation) :**
> >
> > * `ARTIFACTORY_USER` — nom d’utilisateur Artifactory
> > * `ARTIFACTORY_TOKEN` — jeton d’API Artifactory ou mot de passe
> > * `ARTIFACTORY_MAVEN_URL` — URL du dépôt Maven (p. ex., `https://artifactory.example.com/artifactory/maven-virtual`)
> > * `ARTIFACTORY_PYPI_URL` — URL du dépôt PyPI (p. ex., `https://user:token@artifactory.example.com/artifactory/api/pypi/pypi-virtual/simple`)
> > * `ARTIFACTORY_NPM_URL` — URL du dépôt npm (p. ex., `https://artifactory.example.com/artifactory/api/npm/npm-virtual`)
> > * `ARTIFACTORY_DOCKER_URL` — URL du registre Docker (p. ex., `artifactory.example.com`)
>
> Cela serait généralement réparti en trois périmètres :
>
> * **À l’échelle du compte (`initialize`) :** certificat et proxy
> * **À l’échelle de l’organisation (`initialize`) :** Installation des runtimes de langage
> * **À l’échelle de l’organisation (`maintenance`) :** Configuration du registre contenant des références littérales
> * **Commandes de session :** fournir explicitement les secrets, sourcer la configuration de l’environnement et se connecter pour chaque opération Docker
>
> Présenté ici en version combinée pour référence :
>
> ```yaml theme={null}
> initialize:
>   # ── À l'échelle du compte : réseau et confiance ──────────────────────────────────────
>
>   - name: Install corporate CA certificate
>     run: |
>       set -o pipefail
>       printf '%s' "$CORP_ROOT_CA_B64" | base64 -d | openssl x509 -outform PEM \
>         | sudo tee /usr/local/share/ca-certificates/corp-root-ca.crt > /dev/null
>       sudo update-ca-certificates
>       echo 'export NODE_EXTRA_CA_CERTS=/usr/local/share/ca-certificates/corp-root-ca.crt' \
>         | sudo tee /etc/profile.d/node-ca.sh > /dev/null
>
>   - name: Configure system-wide proxy
>     run: |
>       cat << 'PROXY' | sudo tee /etc/profile.d/proxy.sh > /dev/null
>       export http_proxy="$CORP_HTTP_PROXY"
>       export https_proxy="$CORP_HTTPS_PROXY"
>       export no_proxy="$CORP_NO_PROXY"
>       export HTTP_PROXY="$CORP_HTTP_PROXY"
>       export HTTPS_PROXY="$CORP_HTTPS_PROXY"
>       export NO_PROXY="$CORP_NO_PROXY"
>       PROXY
>       source /etc/profile.d/proxy.sh
>
>   # ── À l'échelle de l'organisation : environnements d'exécution ──────────────────────────────────────────
>
>   - name: Install JDK 17 + Maven
>     run: |
>       set -o pipefail
>       source /etc/profile.d/proxy.sh
>       sudo --preserve-env=http_proxy,https_proxy,no_proxy,HTTP_PROXY,HTTPS_PROXY,NO_PROXY \
>         apt-get update -qq
>       sudo --preserve-env=http_proxy,https_proxy,no_proxy,HTTP_PROXY,HTTPS_PROXY,NO_PROXY \
>         DEBIAN_FRONTEND=noninteractive apt-get install -y -qq openjdk-17-jdk-headless
>       echo 'export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64' \
>         | sudo tee /etc/profile.d/java.sh > /dev/null
>
>       MAVEN_VERSION=3.9.9
>       curl -fsSL "https://archive.apache.org/dist/maven/maven-3/${MAVEN_VERSION}/binaries/apache-maven-${MAVEN_VERSION}-bin.tar.gz" \
>         | sudo tar -xz -C /opt
>       sudo ln -sf /opt/apache-maven-${MAVEN_VERSION}/bin/mvn /usr/local/bin/mvn
>
>   - name: Install uv
>     run: |
>       set -o pipefail
>       source /etc/profile.d/proxy.sh
>       curl -LsSf https://astral.sh/uv/install.sh | sh
>
> maintenance:
>   # ── À l'échelle de l'organisation : configuration du registre ───────────────────────────────────
>
>   - name: Configure Maven → Artifactory
>     run: |
>       mkdir -p ~/.m2
>       cat > ~/.m2/settings.xml <<'EOF'
>       <settings>
>         <mirrors>
>           <mirror>
>             <id>artifactory</id>
>             <mirrorOf>*</mirrorOf>
>             <url>${env.ARTIFACTORY_MAVEN_URL}</url>
>           </mirror>
>         </mirrors>
>         <servers>
>           <server>
>             <id>artifactory</id>
>             <username>${env.ARTIFACTORY_USER}</username>
>             <password>${env.ARTIFACTORY_TOKEN}</password>
>           </server>
>         </servers>
>       </settings>
>       EOF
>
>   - name: Configure pip/uv → Artifactory PyPI
>     run: |
>       mkdir -p ~/.config
>       cat > ~/.config/private-pypi.sh <<'EOF'
>       export PIP_INDEX_URL="$ARTIFACTORY_PYPI_URL"
>       export UV_INDEX_URL="$ARTIFACTORY_PYPI_URL"
>       EOF
>
>   - name: Configure npm → Artifactory
>     run: |
>       npm config set registry '${ARTIFACTORY_NPM_URL}'
>       REGISTRY_HOST=$(echo "$ARTIFACTORY_NPM_URL" | sed 's|https\?://||;s|/.*||')
>       npm config set "//${REGISTRY_HOST}/:_authToken" '${ARTIFACTORY_TOKEN}'
>
> knowledge:
>   - name: private_packages
>     contents: |
>       With the corresponding secrets available, source setup in each command:
>         source /etc/profile.d/proxy.sh && mvn dependency:resolve
>         source /etc/profile.d/proxy.sh && npm install
>         source /etc/profile.d/proxy.sh && source ~/.config/private-pypi.sh && uv sync
>   - name: private_container_images
>     contents: |
>       With the Artifactory and proxy secrets available, run in one shell.
>       Replace team/image:tag with the image to pull:
>         (
>           set -euo pipefail
>           umask 077
>           source /etc/profile.d/proxy.sh
>           DOCKER_CONFIG=$(mktemp -d)
>           export DOCKER_CONFIG
>           trap 'rm -rf "$DOCKER_CONFIG"' EXIT
>           printf '%s' "$ARTIFACTORY_TOKEN" |
>             docker login "$ARTIFACTORY_DOCKER_URL" \
>               --username "$ARTIFACTORY_USER" --password-stdin
>           docker pull "$ARTIFACTORY_DOCKER_URL/team/image:tag"
>         )
> ```
>
> > [!NOTE]
> >
> > Dans cet exemple, tous les registres pointent vers la même instance Artifactory, mais utilisent des chemins d’URL différents. Chaque écosystème de packages a son propre format d’endpoint. Les URL Maven, PyPI, npm et Docker sont toutes différentes, même pour un même registre.

> [accordion] Plusieurs langages avec différents dépôts
>
> Lorsque différents langages utilisent des registres privés différents (par ex. Maven via Nexus, npm via GitHub Packages, Python via Artifactory).
>
> > [accordion] Secrets requis
> >
> > * `NEXUS_MAVEN_URL` — URL du dépôt Maven Nexus
> > * `NEXUS_USER` — nom d’utilisateur Nexus
> > * `NEXUS_PASS` — mot de passe Nexus
> > * `GITHUB_PACKAGES_TOKEN` — jeton d’accès personnel GitHub avec le périmètre `read:packages`
> > * `ARTIFACTORY_USER` — nom d’utilisateur Artifactory
> > * `ARTIFACTORY_TOKEN` — jeton d’API Artifactory
>
> Connectez votre Git provider et accordez l’accès aux repositories qui hébergent les modules Go via les [Git integrations](https://docs.devin.ai/fr/integrations/overview.md).
>
> ```yaml theme={null}
> maintenance:
>   # Maven → Nexus
>   - name: Configure Maven → Nexus
>     run: |
>       mkdir -p ~/.m2
>       cat > ~/.m2/settings.xml <<'EOF'
>       <settings>
>         <mirrors>
>           <mirror>
>             <id>nexus</id>
>             <mirrorOf>*</mirrorOf>
>             <url>${env.NEXUS_MAVEN_URL}</url>
>           </mirror>
>         </mirrors>
>         <servers>
>           <server>
>             <id>nexus</id>
>             <username>${env.NEXUS_USER}</username>
>             <password>${env.NEXUS_PASS}</password>
>           </server>
>         </servers>
>       </settings>
>       EOF
>
>   # npm → GitHub Packages (avec périmètre)
>   - name: Configure npm → GitHub Packages
>     run: |
>       npm config set @myorg:registry https://npm.pkg.github.com
>       npm config set //npm.pkg.github.com/:_authToken '${GITHUB_PACKAGES_TOKEN}'
>
>   # Python → Artifactory
>   - name: Configure pip → Artifactory
>     run: |
>       mkdir -p ~/.config
>       cat > ~/.config/private-pypi.sh <<'EOF'
>       export PIP_INDEX_URL="https://$ARTIFACTORY_USER:$ARTIFACTORY_TOKEN@artifactory.example.com/artifactory/api/pypi/pypi-virtual/simple"
>       EOF
>
>   # Go → modules privés via le Git provider connecté
>   - name: Configure Go private modules
>     run: |
>       go env -w GOPRIVATE=github.com/myorg/*
>
> knowledge:
>   - name: private_python_packages
>     contents: |
>       With URL-encoded ARTIFACTORY_USER and ARTIFACTORY_TOKEN available, run:
>         source ~/.config/private-pypi.sh && pip install -r requirements.txt
> ```

> [accordion] Environnement en air gap avec des miroirs privés
>
> Dans un environnement totalement en air gap, Devin ne peut accéder à aucune URL publique. Tous les outils, environnements d’exécution et packages doivent provenir de miroirs internes.
>
> > [accordion] Secrets requis
> >
> > **Certificats :**
> >
> > * `CORP_ROOT_CA_B64` — certificat d’autorité de certification de l’entreprise encodé en Base64
> >
> > **Accès au miroir :**
> >
> > * `APT_MIRROR_URL` — URL du miroir APT Ubuntu interne
> > * `MIRROR_USER` — nom d’utilisateur d’authentification au miroir
> > * `MIRROR_PASS` — mot de passe d’authentification au miroir
> > * `JDK_TARBALL_URL` — URL pour télécharger l’archive tar du JDK depuis le miroir interne
> > * `NODE_TARBALL_URL` — URL pour télécharger l’archive tar de Node.js depuis le miroir interne
> >
> > **Registres de packages :**
> >
> > * `INTERNAL_MAVEN_URL` — URL du registre Maven interne
> > * `INTERNAL_NPM_URL` — URL du registre npm interne
> > * `INTERNAL_PYPI_URL` — URL du registre PyPI interne
>
> ```yaml theme={null}
> initialize:
>   - name: Install corporate CA certificate
>     run: |
>       set -o pipefail
>       printf '%s' "$CORP_ROOT_CA_B64" | base64 -d | openssl x509 -outform PEM \
>         | sudo tee /usr/local/share/ca-certificates/corp-root-ca.crt > /dev/null
>       sudo update-ca-certificates
>
>   - name: Replace apt sources with internal mirror
>     run: |
>       sudo sed -i "s|http://archive.ubuntu.com/ubuntu|$APT_MIRROR_URL|g" /etc/apt/sources.list
>       sudo sed -i "s|http://security.ubuntu.com/ubuntu|$APT_MIRROR_URL|g" /etc/apt/sources.list
>       sudo apt-get update -qq
>
>   - name: Install JDK from internal mirror
>     run: |
>       # Télécharger l'archive JDK depuis le dépôt d'artefacts interne
>       curl -fsSL -u "$MIRROR_USER:$MIRROR_PASS" "$JDK_TARBALL_URL" \
>         | sudo tar -xz -C /usr/local
>       sudo ln -sf /usr/local/jdk-17.*/bin/java /usr/local/bin/java
>       sudo ln -sf /usr/local/jdk-17.*/bin/javac /usr/local/bin/javac
>       echo "export JAVA_HOME=$(ls -d /usr/local/jdk-17.*)" \
>         | sudo tee /etc/profile.d/java.sh > /dev/null
>
>   - name: Install Node.js from internal mirror
>     run: |
>       curl -fsSL -u "$MIRROR_USER:$MIRROR_PASS" "$NODE_TARBALL_URL" \
>         | sudo tar -xz -C /usr/local --strip-components=1
>
> maintenance:
>   - name: Configure all package managers for internal registry
>     run: |
>       # Maven
>       mkdir -p ~/.m2
>       cat > ~/.m2/settings.xml <<'EOF'
>       <settings>
>         <mirrors>
>           <mirror>
>             <id>internal</id>
>             <mirrorOf>*</mirrorOf>
>             <url>${env.INTERNAL_MAVEN_URL}</url>
>           </mirror>
>         </mirrors>
>         <servers>
>           <server>
>             <id>internal</id>
>             <username>${env.MIRROR_USER}</username>
>             <password>${env.MIRROR_PASS}</password>
>           </server>
>         </servers>
>       </settings>
>       EOF
>
>       # npm
>       npm config set registry '${INTERNAL_NPM_URL}'
>
>       # pip
>       mkdir -p ~/.config
>       cat > ~/.config/private-pypi.sh <<'EOF'
>       export PIP_INDEX_URL="$INTERNAL_PYPI_URL"
>       EOF
>
> knowledge:
>   - name: internal_python_packages
>     contents: |
>       With INTERNAL_PYPI_URL available, run:
>         source ~/.config/private-pypi.sh && pip install -r requirements.txt
> ```
>
> > [!WARNING]
> >
> > Dans les environnements en air gap, tous les outils dont Devin a besoin (environnement d’exécution, outils CLI, etc.) doivent être disponibles sur vos miroirs internes. Les registres publics et les sites de téléchargement ne sont pas accessibles.

> [accordion] VPN + certificats + proxy + langages
>
> Une configuration Enterprise complète combinant les outils VPN, des certificats, la configuration du proxy et la prise en charge multilingue. Le blueprint installe les outils et stocke la configuration avec des références littérales. Connectez explicitement le VPN lorsque vous exécutez des opérations nécessitant un accès interne.
>
> > [accordion] Secrets requis
> >
> > **VPN :**
> >
> > * `VPN_CONFIG_B64` — fichier de configuration OpenVPN encodé en Base64
> >
> > **Réseau & confiance :**
> >
> > * `CORP_ROOT_CA_B64` — certificat d’autorité de certification d’entreprise encodé en Base64
> > * `CORP_HTTP_PROXY` — URL du proxy HTTP
> > * `CORP_HTTPS_PROXY` — URL du proxy HTTPS
> > * `CORP_NO_PROXY` — hôtes à ne pas faire passer par le proxy
> >
> > **Identifiants du registre :**
> >
> > * `MAVEN_REGISTRY_URL` — URL du registre Maven
> > * `NPM_REGISTRY_URL` — URL du registre npm
> > * `PYPI_REGISTRY_HOST` — nom d’hôte du registre PyPI
> > * `REGISTRY_USER` — nom d’utilisateur du registre (pour Maven et pip)
> > * `REGISTRY_PASS` — mot de passe du registre (pour Maven et pip)
> > * `REGISTRY_TOKEN` — jeton d’authentification npm
>
> ```yaml theme={null}
> initialize:
>   # 1. Client VPN
>   - name: Install VPN client
>     run: |
>       sudo DEBIAN_FRONTEND=noninteractive apt-get update -qq
>       sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq openvpn
>
>   # 2. DNS — résolution des noms d'hôtes internes
>   - name: Configure DNS
>     run: |
>       sudo mkdir -p /etc/systemd/resolved.conf.d
>       cat << 'DNS' | sudo tee /etc/systemd/resolved.conf.d/corp.conf > /dev/null
>       [Resolve]
>       DNS=10.0.0.53
>       Domains=corp.internal
>       DNS
>       sudo systemctl restart systemd-resolved || true
>
>   # 3. Certificats — approuver les autorités de certification internes
>   - name: Install CA certificate
>     run: |
>       set -o pipefail
>       printf '%s' "$CORP_ROOT_CA_B64" | base64 -d | openssl x509 -outform PEM \
>         | sudo tee /usr/local/share/ca-certificates/corp-root-ca.crt > /dev/null
>       sudo update-ca-certificates
>       echo 'export NODE_EXTRA_CA_CERTS=/usr/local/share/ca-certificates/corp-root-ca.crt' \
>         | sudo tee /etc/profile.d/node-ca.sh > /dev/null
>
>   # 4. Proxy — acheminer le trafic via le proxy d'entreprise
>   - name: Configure proxy
>     run: |
>       cat << 'PROXY' | sudo tee /etc/profile.d/proxy.sh > /dev/null
>       export http_proxy="$CORP_HTTP_PROXY"
>       export https_proxy="$CORP_HTTPS_PROXY"
>       export no_proxy="$CORP_NO_PROXY"
>       export HTTP_PROXY="$CORP_HTTP_PROXY"
>       export HTTPS_PROXY="$CORP_HTTPS_PROXY"
>       export NO_PROXY="$CORP_NO_PROXY"
>       PROXY
>       source /etc/profile.d/proxy.sh
>
>   # 5. Environnements d'exécution
>   - name: Install language runtimes over VPN
>     run: |
>       (
>         set -euo pipefail
>         umask 077
>         VPN_DIR=$(mktemp -d)
>         cleanup() {
>           if [ -f "$VPN_DIR/openvpn.pid" ]; then
>             sudo kill "$(cat "$VPN_DIR/openvpn.pid")" || true
>           fi
>           sudo rm -rf "$VPN_DIR"
>         }
>         trap cleanup EXIT
>         printf '%s' "$VPN_CONFIG_B64" | base64 -d > "$VPN_DIR/corp.conf"
>         sudo openvpn --config "$VPN_DIR/corp.conf" \
>           --writepid "$VPN_DIR/openvpn.pid" --daemon
>         for i in $(seq 1 30); do
>           if ip link show tun0 >/dev/null 2>&1; then break; fi
>           sleep 1
>         done
>         ip link show tun0 >/dev/null
>         source /etc/profile.d/proxy.sh
>         sudo --preserve-env=http_proxy,https_proxy,no_proxy,HTTP_PROXY,HTTPS_PROXY,NO_PROXY \
>           apt-get update -qq
>         sudo --preserve-env=http_proxy,https_proxy,no_proxy,HTTP_PROXY,HTTPS_PROXY,NO_PROXY \
>           DEBIAN_FRONTEND=noninteractive apt-get install -y -qq openjdk-17-jdk-headless
>         echo 'export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64' \
>           | sudo tee /etc/profile.d/java.sh > /dev/null
>         npm install -g pnpm
>         curl -LsSf https://astral.sh/uv/install.sh | sh
>       )
>
> maintenance:
>   - name: Configure Maven
>     run: |
>       mkdir -p ~/.m2
>       cat > ~/.m2/settings.xml <<'EOF'
>       <settings>
>         <mirrors>
>           <mirror>
>             <id>corp</id>
>             <mirrorOf>*</mirrorOf>
>             <url>${env.MAVEN_REGISTRY_URL}</url>
>           </mirror>
>         </mirrors>
>         <servers>
>           <server>
>             <id>corp</id>
>             <username>${env.REGISTRY_USER}</username>
>             <password>${env.REGISTRY_PASS}</password>
>           </server>
>         </servers>
>       </settings>
>       EOF
>
>   - name: Configure npm
>     run: |
>       npm config set registry '${NPM_REGISTRY_URL}'
>       NPM_HOST=$(echo "$NPM_REGISTRY_URL" | sed 's|https\?://||;s|/.*||')
>       npm config set "//${NPM_HOST}/:_authToken" '${REGISTRY_TOKEN}'
>
>   - name: Configure pip/uv
>     run: |
>       mkdir -p ~/.config
>       cat > ~/.config/private-pypi.sh <<'EOF'
>       export PIP_INDEX_URL="https://$REGISTRY_USER:$REGISTRY_PASS@${PYPI_REGISTRY_HOST}/simple"
>       export UV_INDEX_URL="$PIP_INDEX_URL"
>       EOF
>
> knowledge:
>   - name: internal_packages
>     contents: |
>       Use the temporary OpenVPN setup/cleanup block from the template library
>       when an operation needs VPN access. Inside that block, with the registry
>       and proxy secrets available, replace the sample curl command with:
>         source /etc/profile.d/proxy.sh
>         mvn dependency:resolve
>         npm install
>         source ~/.config/private-pypi.sh
>         uv sync
>       Percent-encode the pip URL credentials. Disconnect the VPN and remove its
>       temporary files when the operation finishes.
> ```
>
> > [!NOTE]
> >
> > **Un accès d’amorçage est requis.** Le client OpenVPN doit être préinstallé ou installable avant l’établissement du tunnel. `VPN_CONFIG_B64` doit contenir les certificats/clés en ligne, utiliser `dev tun0` et se connecter sans authentification interactive. Les téléchargements des environnements d’exécution s’effectuent au sein d’un même cycle de vie du tunnel et chargent explicitement l’environnement du proxy. Répétez le bloc de configuration/nettoyage du VPN décrit dans [Réseau et connectivité](#network-and-connectivity) pour les opérations de session ; le blueprint ne reconnecte pas le VPN au début de la session.

***

## Conseils pour rédiger de bons blueprints

* **Testez d’abord les commandes dans une session.** Exécutez-les manuellement dans une session Devin avant de les ajouter à votre blueprint. C’est plus rapide que d’attendre un cycle de build complet.
* **Utilisez `initialize` pour les outils à installer une seule fois, et `maintenance` pour les dépendances.** Tout ce qui prend plusieurs minutes à installer (compilateurs, gros binaires, outils globaux) doit aller dans `initialize`. Les commandes de dépendances rapides (`npm install`, `uv sync`) vont dans `maintenance`.
* **Veillez à ce que les commandes `maintenance` restent rapides.** Visez moins de 2 minutes. Elles s’exécutent pendant les builds et sont exposées à l’agent au démarrage de la session.
* **Utilisez `$ENVRC` pour les variables d’environnement non sensibles.** N’écrivez pas de credentials ni de tokens dérivés dans `$ENVRC`, `.bashrc` ou `.profile`. Sourcez explicitement la configuration shell dépendant de secrets dans la commande qui en a besoin.
* **Nommez vos étapes.** La syntaxe développée avec des champs `name` permet d’identifier beaucoup plus facilement les échecs dans les journaux de build.
* **Utilisez des subshells pour les monorepos.** `(cd packages/foo && npm install)` s’exécute dans un subshell afin que les étapes suivantes ne soient pas affectées par le changement de répertoire.
* **Utilisez `npm install`, pas `npm ci`.** `npm ci` supprime `node_modules` et réinstalle tout depuis zéro, ce qui est trop lent pour `maintenance`.
* **Utilisez les secrets du repository pour les valeurs sensibles.** Configurez-les dans l’onglet **Secrets** de l’éditeur de blueprint du repository plutôt que de les coder en dur dans les blueprints.

Pour les détails de syntaxe, consultez la [référence Blueprint](https://docs.devin.ai/fr/onboard-devin/environment/blueprint-reference.md). Pour résoudre les échecs de build, consultez [Configuration déclarative > Dépannage](https://docs.devin.ai/fr/onboard-devin/environment/blueprints.md#troubleshooting-builds).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.