Libreria di template dei blueprint di Devin

Blueprint pronti da copiare e incollare per i linguaggi e i casi d’uso più comuni. Combinali per comporre la tua configurazione completa. Gli esempi usano Bash su Linux; sostituisci host, ambiti e comandi di esempio con i tuoi. Per una descrizione dettagliata di ogni campo, consulta il riferimento del blueprint.

Segreti: configura i segreti indicati nella scheda Segreti all’interno di ciascun editor dei blueprint. I passaggi di build ricevono i segreti del blueprint applicabili. Durante una sessione, assicurati che ogni comando riceva i segreti di cui ha bisogno: i segreti con ambito repo richiedono binding espliciti dell’ambiente exec, ad esempio env={"REGISTRY_TOKEN": "secret:repo:owner/repo:REGISTRY_TOKEN"}. Consulta Secrets. Non inserire mai credenziali in modo hardcoded nel tuo blueprint.

I passaggi di build non sono hook di avvio della sessione. initialize e maintenance vengono eseguiti durante la creazione degli snapshot; maintenance non viene eseguito automaticamente all’avvio della sessione. knowledge fornisce istruzioni a Devin, non hook eseguibili.Tieni le credenziali fuori dai file persistenti, incluso $ENVRC. La pulizia degli snapshot rimuove i file di segreti iniettati da Devin, non i file arbitrari creati dai tuoi comandi. Usa i riferimenti letterali a variabili supportati dallo strumento che li utilizza, oppure passa le credenziali nell’ambiente del comando. Quando uno strumento richiede file di credenziali, creali per una singola operazione ed eliminali prima che si concluda. Ripeti esplicitamente questa configurazione quando serve nel corso di una sessione.

Guida rapida

Blueprint essenziali per le configurazioni più comuni. Copiane uno, incollalo nell’editor dei blueprint e il gioco è fatto.

Progetto Node.js

initialize: |
  npm install -g pnpm

maintenance: |
  pnpm install

knowledge:
  - name: lint
    contents: |
      Esegui `pnpm lint` per verificare eventuali errori.
  - name: test
    contents: |
      Esegui `pnpm test` per la suite completa.

Progetto Python

initialize: |
  curl -LsSf https://astral.sh/uv/install.sh | sh

maintenance: |
  uv sync

knowledge:
  - name: lint
    contents: |
      Esegui `uv run ruff check .` per il linting.
  - name: test
    contents: |
      Esegui `uv run pytest` per la suite completa.

Full-stack (Node + Python)

initialize:
  - name: Install pnpm
    run: npm install -g pnpm
  - name: Install uv
    run: curl -LsSf https://astral.sh/uv/install.sh | sh

maintenance:
  - name: Dipendenze frontend
    run: (cd frontend && pnpm install)
  - name: Dipendenze backend
    run: (cd backend && uv sync)

knowledge:
  - name: structure
    contents: |
      - `frontend/` — app React (pnpm)
      - `backend/` — API Python (uv)
  - name: test
    contents: |
      Frontend: cd frontend && pnpm test
      Backend: cd backend && uv run pytest

Blueprint dei repository

Passaggi di build per ciascun repo, gestione delle dipendenze e voci di Knowledge. Configurali in Settings > Ambiente > Blueprint > [il tuo repo].

Python

uv (consigliato)
pip + venv

Configurazione consigliata per i progetti Python che usano uv per la gestione delle dipendenze.

initialize: |
  curl -LsSf https://astral.sh/uv/install.sh | sh

maintenance: |
  uv sync

knowledge:
  - name: lint
    contents: |
      uv run ruff check .

      Correzione automatica:
      uv run ruff check --fix .

  - name: test
    contents: |
      uv run pytest

  - name: build
    contents: |
      uv run python -m build

Configurazione Python tradizionale con pip e venv. Da usare quando il progetto si basa su requirements.txt.

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

npm
pnpm

Configurazione Standard di Node.js con npm.

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

Usa npm install (non npm ci) in maintenance. Esegue un aggiornamento incrementale, mentre npm ci elimina node_modules e reinstalla tutto da zero a ogni esecuzione del comando.

Per i progetti che usano pnpm.

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

Configurazione standard di Go con moduli.

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

Gradle
Maven

Configurazione di Java con Gradle.

JDK 17 è preinstallato nell’immagine di base di Devin. Salta il passaggio di installazione del JDK se OpenJDK 17 predefinito è sufficiente.

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

Configurazione di Java con Maven.

JDK 17 è preinstallato nell’immagine di base di Devin. Salta il passaggio di installazione del JDK se OpenJDK 17 predefinito è sufficiente.

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

Configurazione di Rails con PostgreSQL.

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

Configurazione Rust standard con Cargo.

Rust (tramite rustup) e Cargo sono preinstallati nell’immagine di base di Devin. Salta il passaggio di installazione se la toolchain stabile predefinita è sufficiente. Devi solo scaricare le dipendenze.

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

Monorepo

Multilingue
Versioni multiple di JDK

Monorepo con frontend Node.js e backend Python. Ogni sottoprogetto ha le proprie voci di Knowledge.

initialize:
  - name: Install pnpm
    run: npm install -g pnpm
  - name: Install uv
    run: curl -LsSf https://astral.sh/uv/install.sh | sh

maintenance:
  - name: Install frontend dependencies
    run: (cd packages/frontend && pnpm install)
  - name: Install backend dependencies
    run: (cd packages/backend && uv sync)
  - name: Build shared library
    run: (cd packages/shared && pnpm install && pnpm build)

knowledge:
  - name: structure
    contents: |
      Questo è un monorepo con tre package:
      - `packages/frontend` — app React (TypeScript, pnpm)
      - `packages/backend` — API Python (FastAPI, uv)
      - `packages/shared` — utilità TypeScript condivise (da buildare prima del frontend)
  - name: frontend
    contents: |
      Esegui `cd packages/frontend && pnpm dev` per avviare il server di sviluppo.
      Esegui `cd packages/frontend && pnpm lint` per eseguire il lint.
      Esegui `cd packages/frontend && pnpm test` per eseguire i test.
  - name: backend
    contents: |
      Esegui `cd packages/backend && uv run uvicorn app.main:app --reload` per avviare l'API.
      Esegui `cd packages/backend && uv run ruff check .` per eseguire il lint.
      Esegui `cd packages/backend && uv run pytest` per eseguire i test.

Usa le subshell (cd dir && command) invece di cd dir && command, così la directory di lavoro viene reimpostata tra un passaggio e l’altro.

Un monorepo Java in cui servizi diversi richiedono versioni diverse del JDK. Installa entrambi i JDK durante la configurazione, poi usa le voci di knowledge per indicare a Devin quale JAVA_HOME usare per ciascun servizio.

initialize:
  - name: Install JDK 17 (primary)
    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 JDK 11 (legacy service)
    run: |
      sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq openjdk-11-jdk-headless

maintenance:
  - name: Warm dependency caches
    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: |
      Esegui la build del servizio API (JDK 17):
        JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64 \
        cd services/api && ./gradlew clean build
  - name: build_legacy
    contents: |
      Esegui la build del servizio legacy (JDK 11):
        JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64 \
        cd services/legacy && ./gradlew clean build
  - name: test_all
    contents: |
      Esegui i test per tutti i servizi:
        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)

Private package registries

Configura i gestori di pacchetti in modo che risolvano le dipendenze dai registry privati. Imposta questi valori in Settings > Environment > Blueprints > Org-wide setup (oppure sul singolo repo, se serve solo a uno).

Memorizza i riferimenti, non le credenziali espanse. I delimitatori heredoc tra apici, come <<'EOF', preservano i riferimenti alle variabili all’interno del file. npm, Yarn Berry, Maven e Gradle sono in grado di risolvere i riferimenti mostrati di seguito al momento dell’esecuzione. pip non espande le variabili di shell in pip.conf: in quel caso usa le variabili d’ambiente. I file di setup della shell devono essere caricati esplicitamente con source nello stesso comando dello strumento; non dare per scontato che una nuova shell li carichi o aggiorni le credenziali.Gli URL scritti direttamente in configurazioni persistenti, come un indice Cargo, un mirror Docker o un mirror APT, non devono contenere credenziali. Mantieni l’authentication nei segreti separati mostrati in ciascun template.Se hai usato un template più vecchio che scriveva le credenziali su disco, rimuovi quei file ed esegui il rebuild da una base pulita, non da uno snapshot che le contiene. Ruota le credenziali che potrebbero essere state acquisite.

Se il tuo registry privato usa una CA corporate, assicurati di installare prima il certificato CA a livello enterprise. La configurazione seguente presuppone che l’attendibilità HTTPS sia già stabilita.

Registry Node.js

npm (ambito)
npm (mirror completo)
pnpm
Yarn

Configura npm per risolvere i pacchetti con ambito (ad es. @myorg/*) da un registry privato, mentre i pacchetti pubblici continuano a provenire dal registry npm predefinito.

Segreti richiesti

GITHUB_PACKAGES_TOKEN — Token di accesso personale o token GitHub App con ambito read:packages

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}'

Sostituisci @myorg con il tuo scope npm. URL comuni dei registry privati:

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>

Instrada tutti i pacchetti npm attraverso il tuo registry privato (non solo i pacchetti con ambito).

Segreti richiesti

NPM_REGISTRY_URL — URL completo del tuo registry npm (ad es. https://artifactory.example.com/artifactory/api/npm/npm-virtual)
NPM_REGISTRY_HOST — Solo hostname, senza protocollo (ad es. artifactory.example.com)
REGISTRY_TOKEN — Token di autenticazione npm per il registry

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

Configura pnpm per risolvere i pacchetti da un registry privato.

Segreti richiesti

NPM_REGISTRY_URL — URL completo del tuo registry npm
NPM_REGISTRY_HOST — Solo hostname, senza protocollo
REGISTRY_TOKEN — Token di autenticazione npm per il registry

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}'

Configura Yarn (Classic v1 o Berry v2+) per risolvere i pacchetti da un registry privato.

Segreti richiesti

NPM_REGISTRY_URL — URL completo del tuo registry npm/Yarn
REGISTRY_TOKEN — Token di autenticazione per il registry

Yarn Classic (v1):

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}'

Sostituisci registry.example.com con l’host del tuo registry. Yarn Classic legge il file .npmrc di npm.Yarn Berry (v2+):

maintenance:
  - name: Configure Yarn Berry for private registry
    run: |
      yarn config set npmRegistryServer '${NPM_REGISTRY_URL}'
      yarn config set npmAuthToken '${REGISTRY_TOKEN}'
      # Per i pacchetti con ambito:
      # yarn config set npmScopes.myorg.npmRegistryServer "https://npm.pkg.github.com"
      # yarn config set npmScopes.myorg.npmAuthToken '${GITHUB_PACKAGES_TOKEN}'

Registry Python

pip / uv
Poetry

Configura pip e uv per recuperare i pacchetti dal tuo registry PyPI privato (ad es. Nexus, Artifactory).

Segreti richiesti

PYPI_REGISTRY_URL — URL completo del tuo indice PyPI, incluse le credenziali se richieste (ad es. https://user:token@nexus.example.com/repository/pypi-proxy/simple)

maintenance:
  - name: Configura pip/uv per il registry privato
    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: |
      Con PYPI_REGISTRY_URL disponibile nell'ambiente del comando, esegui:
        source ~/.config/private-pypi.sh && uv sync
      Oppure:
        source ~/.config/private-pypi.sh && pip install -r requirements.txt

Per precaricare le dipendenze durante un build, aggiungi lo stesso comando source ... && a maintenance dopo il passaggio di configurazione. Codifica in percent-encoding i caratteri speciali nelle credenziali dell’URL.

URL comuni dei registry 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

Configura Poetry per recuperare i pacchetti da un registry PyPI privato.

Segreti richiesti

POETRY_REGISTRY_URL — URL completo del tuo registry compatibile con PyPI
REGISTRY_USER — Nome utente del registry
REGISTRY_PASS — Password del registry o token API

initialize:
  - name: Installa Poetry
    run: curl -sSL https://install.python-poetry.org | python3 -

maintenance:
  - name: Configura Poetry per il registry privato
    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: |
      Con REGISTRY_USER e REGISTRY_PASS disponibili, esegui:
        source ~/.config/private-poetry.sh && poetry install

Per l’installazione delle dipendenze, dichiara anche la sorgente del pacchetto private nel pyproject.toml del tuo progetto. poetry config repositories.private configura il repository di pubblicazione; le credenziali dell’ambiente si applicano al nome della sorgente corrispondente.

Registry JVM

Maven
Gradle

Installa il JDK e configura Maven in modo che tutta la risoluzione delle dipendenze passi attraverso il tuo registry privato (ad es., Artifactory, Nexus).

JDK 17 è preinstallato nell’immagine di base di Devin. Salta il passaggio di installazione se l’OpenJDK 17 predefinito è sufficiente. Ti servono solo l’installazione di Maven e la configurazione del registry.

Segreti richiesti

MAVEN_REGISTRY_URL — URL del tuo registry Maven (ad es., https://artifactory.example.com/artifactory/maven-virtual)
REGISTRY_USER — Nome utente del registry
REGISTRY_PASS — Password del registry o token API

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

Pattern di URL comuni dei registry 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>

Installa il JDK e configura Gradle per risolvere tutte le dipendenze tramite il tuo registry privato.

JDK 17 è preinstallato nell’immagine di base di Devin. Salta il passaggio di installazione del JDK se la versione predefinita è sufficiente.

Segreti richiesti

GRADLE_REGISTRY_URL — URL del tuo registry Gradle/Maven
REGISTRY_USER — Nome utente del registry
REGISTRY_PASS — Password del registry o token API

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

Altri registry

Proxy dei moduli Go

Installa Go e configuralo per risolvere i moduli tramite un proxy di moduli privato (ad es. Athens, Artifactory o un endpoint GOPROXY).

Segreti richiesti

GO_PROXY_URL — URL del tuo proxy di moduli Go (ad es. https://athens.corp.internal)

Collega il Git provider e concedi l’accesso ai repository che ospitano i tuoi moduli privati tramite le integrazioni Git. Usa normali git URL HTTPS con l’authentication configurata di Devin. Non incorporare un token in una riscrittura del git URL.

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

Per precaricare la cache dei moduli durante le build, aggiungi quel comando alla sezione maintenance del blueprint del repository, dove go.mod è disponibile. Non eseguirlo nell’org-wide setup, che viene eseguito prima della clonazione dei repo.

Pattern comuni di URL per il proxy Go:

Artifactory: https://artifactory.example.com/artifactory/go-virtual
Nexus: https://nexus.example.com/repository/go-proxy
Athens: https://athens.corp.internal

.NET / NuGet

Configura NuGet per risolvere i package da un feed privato.

Segreti richiesti

NUGET_SOURCE_URL — URL del tuo feed NuGet
NuGetPackageSourceCredentials_private — Credenziali del feed nel formato environment di NuGet: Username=any;Password=<PAT> (usa lo username richiesto dal tuo feed)

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".

Docker

Configura Docker per effettuare il pull da un container registry privato.Il login di Docker può scrivere le credenziali nella propria directory di configurazione. Usa una directory isolata per ogni operazione e rimuovila anche se il pull non riesce. Ripeti la sequenza di login e pull ogni volta che ti serve un’altra image nella stessa sessione.

Segreti richiesti

DOCKER_MIRROR_URL (opzionale) — URL del tuo mirror di Docker Hub (ad es. https://mirror.corp.internal)
DOCKER_REGISTRY_URL — URL del tuo container registry privato (ad es. registry.corp.internal:5000)
DOCKER_REGISTRY_USER — Nome utente del registry
DOCKER_REGISTRY_PASS — Password o token API del registry

initialize:
  - name: Create Docker config directory
    run: sudo mkdir -p /etc/docker

maintenance:
  - name: Configure Docker for private registry
    run: |
      # Configura il mirror del registry (opzionale — instrada i pull da Docker Hub attraverso il tuo registry)
      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"
        )

Per memorizzare nella cache un’image nello snapshot, inserisci la stessa subshell completa in un passaggio di build. Non suddividere login e pulizia in passaggi diversi e verifica che la pulizia vada a buon fine prima di creare l’image. L’URL di un mirror del registry non deve contenere credentials.

URL comuni dei container registry:

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

Rust / Cargo

Configura Cargo per risolvere i crate da un registry privato.

Rust (tramite rustup) e Cargo sono preinstallati nell’immagine di base di Devin. Salta il passaggio di installazione se la toolchain stable predefinita è sufficiente: ti serve solo la configurazione del registry.

Segreti richiesti

CARGO_REGISTRY_INDEX — URL dell’indice del registry privato (ad es. sparse+https://cargo.corp.internal/api/v1/crates/)
CARGO_REGISTRIES_PRIVATE_TOKEN — Token di autenticazione per il registry denominato private

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 dell’index del registry non deve contenere credenziali. Il provider cargo:token di Cargo legge dall’ambiente il token del registry indicato; non eseguire cargo login in un passaggio di build.

Se devi solo aggiungere un registry privato senza sostituire crates.io, rimuovi le sezioni [source.crates-io] e [source.private] e usa cargo install --registry private oppure [dependencies] my-crate = { version = "1.0", registry = "private" } in Cargo.toml.

Ruby / Bundler

Installa Ruby e configura Bundler per risolvere le gem da un gem server privato.

Segreti richiesti

GEM_SERVER_URL — URL del tuo gem server privato (ad es. https://artifactory.example.com/artifactory/api/gems/gems-virtual)
BUNDLE_ARTIFACTORY__EXAMPLE__COM — username:password per artifactory.example.com; modifica il nome della variabile in base al tuo gem server

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.

Usa un GEM_SERVER_URL senza credenziali. Per la variabile delle credenziali di Bundler, anteponi BUNDLE_ all’hostname in maiuscolo, sostituisci ogni punto con __ e ogni trattino con ___.

Pattern comuni di URL dei gem server:

Artifactory: https://artifactory.example.com/artifactory/api/gems/gems-virtual
Nexus: https://nexus.example.com/repository/rubygems-proxy
Gemfury: https://gem.fury.io/<org>

PHP / Composer

Installa PHP e configura Composer per risolvere i pacchetti da un registry Packagist o Satis privato.

Segreti richiesti

COMPOSER_REGISTRY_URL — URL del tuo registry Composer privato (ad es. https://repo.packagist.com/<org>)
COMPOSER_AUTH — credenziali JSON per l’host del registry, ad esempio {"http-basic":{"repo.packagist.com":{"username":"<user>","password":"<token>"}}}

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

      # Installa 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.

Usa un COMPOSER_REGISTRY_URL senza credenziali.

Pattern comuni di URL per i registry 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

Rinnovo del token AWS CodeArtifact

I token di AWS CodeArtifact scadono normalmente dopo 12 ore. Crea uno script contenente riferimenti letterali, quindi eseguine esplicitamente il source nello stesso shell command di npm, pip o Maven per ottenere un token. Salvare lo script in un blueprint non ne comporta l’esecuzione all’avvio della sessione.

awscli è pre-installato sull’immagine di base di Devin. Ti servono solo l’aggiornamento del token e la configurazione del registry.

Segreti richiesti

AWS_ACCESS_KEY_ID e AWS_SECRET_ACCESS_KEY — credenziali IAM con le autorizzazioni codeartifact:GetAuthorizationToken e sts:GetServiceBearerToken
CA_DOMAIN — il nome del tuo dominio CodeArtifact
CA_DOMAIN_OWNER — ID dell’AWS account proprietario del dominio
CA_REGION — regione AWS (ad es. us-east-1)
CA_NPM_REPO, CA_PYPI_REPO, CA_MAVEN_REPO — nomi dei repository per ciascun ecosistema

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

      # Configura 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}'

      # Configura Maven (opzionale)
      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

Per precaricare una cache delle dipendenze nello snapshot, aggiungi il comando source ... && appropriato come passaggio di build successivo. Il token recuperato rimane nell’ambiente di quella shell: non renderlo persistente con aws codeartifact login, con npm config set usando un token espanso o con un file pip.conf contenente credenziali.

Infrastruttura Enterprise

Infrastruttura a livello di macchina valida per tutte le org e repo. Impostala in Settings > ambiente di base di Devin (a livello di Enterprise) oppure in Settings > Environment > blueprint > configurazione a livello di org (a livello di org).

Rete e connettività

Certificato CA aziendale

La tua organizzazione utilizza un’autorità di certificazione privata per i servizi interni. Devin richiede il certificato radice per accedere ai registry interni e agli strumenti tramite HTTPS.

Segreti richiesti

CORP_ROOT_CA_B64 — certificato PEM codificato in Base64 della tua CA aziendale. Genera con: cat corp-root-ca.crt | base64 -w0

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

Questi input sono certificati pubblici. openssl x509 scrive solo il certificato analizzato, quindi un’eventuale chiave privata inclusa per errore non viene copiata nell’archivio di attendibilità. Fornisci ogni certificato CA separatamente, come nell’esempio seguente.

Certificati CA multipli

Se la tua organizzazione utilizza più certificati CA (ad es. CA distinte per diversi servizi interni).

Segreti richiesti

CORP_ROOT_CA_B64 — certificato CA principale codificato in Base64
CORP_INTERMEDIATE_CA_B64 — certificato CA intermedio codificato in Base64

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

      # Crea un bundle combinato per gli strumenti che richiedono un singolo file 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

Proxy HTTP/HTTPS

Instrada tutto il traffico di rete tramite un proxy aziendale.

Segreti richiesti

CORP_HTTP_PROXY — URL del proxy HTTP (ad es. http://proxy.corp.example.com:8080)
CORP_HTTPS_PROXY — URL del proxy HTTPS
CORP_NO_PROXY — elenco di host, separati da virgole, da escludere dal proxy (ad es. localhost,127.0.0.1,.corp.example.com)

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

Proxy autenticato

Se il proxy aziendale richiede l’autenticazione tramite nome utente/password.

Segreti richiesti

PROXY_USER — Nome utente del proxy
PROXY_PASS — Password del proxy
PROXY_HOST — hostname e porta del proxy (ad es. proxy.corp.example.com:8080)
CORP_NO_PROXY — host da escludere dal proxy

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

Applica la codifica percent-encoding ai caratteri speciali nel nome utente e nella password del proxy. Git e npm possono utilizzare le variabili d’ambiente del proxy; non copiare un URL del proxy contenente credenziali nella loro configurazione persistente.

Certificato CA + proxy (combinati)

Configurazione combinata per ambienti che richiedono sia una CA aziendale sia un proxy. Questa configurazione è comune negli ambienti enterprise in cui i servizi interni usano certificati privati e tutto il traffico deve passare tramite un proxy.

Segreti richiesti

CORP_ROOT_CA_B64 — certificato CA aziendale codificato in Base64
CORP_HTTP_PROXY, CORP_HTTPS_PROXY — URL del proxy
CORP_NO_PROXY — host da escludere dal proxy

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

Connessione VPN

I tuoi registry privati, i server Git o altri servizi interni sono raggiungibili solo tramite VPN. Installa il client VPN nel blueprint. Stabilisci il tunnel esplicitamente per le operazioni che lo richiedono, quindi disconnettiti e rimuovi i file delle credenziali al termine.

Segreti richiesti

OpenVPN:

VPN_CONFIG_B64 — file di configurazione OpenVPN (.ovpn) codificato in Base64. Genera con: cat corp.ovpn | base64 -w0
VPN_AUTH_USER (facoltativo) — nome utente VPN, se la VPN richiede l’autenticazione con nome utente/password
VPN_AUTH_PASS (facoltativo) — password VPN

WireGuard:

WG_CONFIG_B64 — file di configurazione WireGuard codificato in Base64. Genera con: cat wg0.conf | base64 -w0

OpenVPN:

initialize:
  - name: Install OpenVPN
    run: |
      sudo DEBIAN_FRONTEND=noninteractive apt-get update -qq
      sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq openvpn

Esegui esplicitamente questo block in una sessione in cui i segreti VPN sono disponibili. Sostituisci il comando curl con l’operazione che richiede il tunnel. La configurazione deve contenere inline i certificati e le chiavi richiesti e usare dev tun0; non abilitare un servizio VPN persistente.

(
  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:

initialize:
  - name: Install WireGuard
    run: |
      sudo DEBIAN_FRONTEND=noninteractive apt-get update -qq
      sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq wireguard-tools

Esegui esplicitamente questo block con WG_CONFIG_B64 disponibile, sostituendo il comando curl con la tua operazione:

(
  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
)

Se un build dello snapshot richiede l’accesso VPN, racchiudi tutto il lavoro dipendente nello stesso block, in modo che la pulizia venga completata prima della creazione dell’immagine. Spostare semplicemente la scrittura delle credential in maintenance non le rende temporanee. Non includere nello snapshot un tunnel attivo o una configurazione VPN privata.

Per maggiori dettagli sulla configurazione della VPN, consulta Configurazione della VPN.

Risoluzione DNS personalizzata

I tuoi servizi interni utilizzano nomi DNS privati che non possono essere risolti dal DNS pubblico.

initialize:
  - name: Configure custom DNS resolution
    run: |
      # Aggiungi hostname interni
      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

      # Facoltativamente configura nameserver personalizzati
      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à e sicurezza

GPG commit signing

La tua organizzazione richiede che tutti i commit Git siano firmati e vuoi che GitHub contrassegni i commit di Devin come Verified.

Segreti richiesti

GPG_PRIVATE_KEY_B64 — chiave privata GPG codificata in Base64. Generala con: gpg --export-secret-keys <key-id> | base64 -w0
GPG_SIGNING_KEY — impronta completa della chiave di firma
GIT_USER_NAME — nome dell’autore Git (ad es. Devin AI)
GIT_USER_EMAIL — email dell’autore Git. Deve corrispondere a un UID della chiave GPG, altrimenti GitHub non verificherà la firma.

Carica anche la chiave pubblica corrispondente sull’account GitHub le cui credenziali Devin usa per il push (in GitHub Settings > SSH and GPG keys). GitHub contrassegna i commit come Verified solo se la chiave pubblica di firma è registrata sull’account che ha creato il commit.

Non importare chiavi di firma private durante le build dello snapshot. Dopo aver preparato le modifiche desiderate, esegui esplicitamente questo blocco in una sessione in cui i segreti indicati sono disponibili. Il blocco utilizza un keyring temporaneo e impostazioni Git valide solo per questo commit:

(
  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"
)

Se la chiave richiede una passphrase, completa il flusso approvato dell’agente GPG/pinentry durante l’operazione. Non salvare la passphrase o il keyring nel blueprint o nello snapshot. Ripeti la configurazione del keyring temporaneo per i commit o i tag firmati successivi.

Identità Git e chiavi SSH

Configura l’identità Git e le chiavi SSH di Devin per accedere a server Git privati.Per i Git provider supportati, usa preferibilmente le Git integrations. Per un server che richiede una chiave SSH esplicita, tieni la chiave privata fuori dalla build del blueprint e usala solo per l’operazione di sessione descritta di seguito.

Segreti richiesti

GIT_USER_NAME — nome dell’autore Git
GIT_USER_EMAIL — email dell’autore Git
SSH_PRIVATE_KEY_B64 — chiave privata SSH codificata in Base64. Generala con: cat ~/.ssh/id_ed25519 | base64 -w0
SSH_KNOWN_HOSTS_B64 — voci di known hosts codificate in Base64 e verificate rispetto alle impronte delle chiavi host pubblicate dall’amministratore del tuo server

initialize:
  - name: Configure git identity
    run: |
      git config --global user.name "$GIT_USER_NAME"
      git config --global user.email "$GIT_USER_EMAIL"

Esegui esplicitamente questo blocco nella sessione, sostituendo l’URL Git con quello del tuo server e della tua repo:

(
  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
)

Se ti servono opzioni SSH personalizzate, aggiungile a questa invocazione senza copiare una chiave privata in una configurazione SSH persistente o nella home directory. Ripeti la configurazione per ogni operazione.

Configurazione del sistema

Pacchetti di sistema

Installa pacchetti di sistema che non sono presenti nell’immagine Devin predefinita (ad es. librerie native per l’elaborazione delle immagini o la generazione di PDF).

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

Variabili d'ambiente personalizzate

Imposta variabili d’ambiente persistenti e non segrete da rendere disponibili in ogni sessione. Non scrivere valori segreti o credenziali derivate in $ENVRC.L’approccio consigliato è scrivere righe KEY=VALUE nel file $ENVRC. Le variabili scritte in $ENVRC vengono esportate automaticamente per tutti i passaggi successivi e per la sessione di Devin (in modo analogo a $GITHUB_ENV di GitHub Actions).

initialize:
  - name: Set custom environment variables
    run: |
      echo "CORPORATE_ENV=production" >> $ENVRC
      echo "DEFAULT_REGION=us-east-1" >> $ENVRC
      echo "MAX_RETRIES=3" >> $ENVRC

Puoi anche scrivere le variabili d’ambiente negli script in /etc/profile.d/ per renderle disponibili a livello di sistema:

cat << 'ENVVARS' | sudo tee /etc/profile.d/custom-env.sh > /dev/null
export CORPORATE_ENV=production
export DEFAULT_REGION=us-east-1
ENVVARS

Entrambi gli approcci funzionano. $ENVRC è più semplice ed è consigliato nella maggior parte dei casi.

Impostazioni locali e fuso orario

Le immagini di base predefinite potrebbero avere impostazioni del locale non corrette. Configura il locale e il fuso orario per evitare avvisi da strumenti di build, Java, Python e Git.

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

      # Genera e imposta il 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

      # Imposta il fuso orario
      sudo timedatectl set-timezone UTC 2>/dev/null || \
        sudo ln -sfn /usr/share/zoneinfo/UTC /etc/localtime

Limiti di risorse (ulimits)

Le build Java, Gradle e Node.js raggiungono spesso il limite predefinito di 1024 file aperti. Aumentalo per evitare errori di build.

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

      # Imposta anche il massimo del kernel
      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

Sostituzione del mirror di APT

In ambienti air-gapped o soggetti a restrizioni, sostituisci i repository APT predefiniti di Ubuntu con un mirror interno.

Segreti richiesti

APT_MIRROR_URL — URL del tuo mirror APT interno (ad es. https://artifactory.example.com/artifactory/ubuntu-remote)

initialize:
  - name: Replace APT sources with internal mirror
    run: |
      # Backup delle sorgenti originali
      sudo cp /etc/apt/sources.list /etc/apt/sources.list.bak

      # Sostituisci tutti i mirror Ubuntu con il mirror interno
      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

Pattern di URL comuni per i mirror APT:

Artifactory: https://artifactory.example.com/artifactory/ubuntu-remote
Nexus: https://nexus.example.com/repository/ubuntu-proxy

Pattern avanzati

Variabili di ambiente con direnv

L’ambiente di base di Devin include direnv. Usa initialize per creare i file .envrc. Direnv li carica automaticamente.

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 .

direnv è già configurato nella shell di Devin, quindi le variabili di .envrc vengono caricate automaticamente. Non serve eseguire il source manualmente.

Per le variabili d’ambiente sensibili (API key, token, password del database), usa i segreti del repo invece dei file .envrc e associali esplicitamente ai comandi della sessione che ne hanno bisogno. Espandere un segreto in un file durante una build può comunque farlo finire nello snapshot.

Cambio della versione di Node per singola repo

Usa nvm (preinstallato) per cambiare versione di Node.js per ciascun repository tramite .nvmrc.

initialize: |
  nvm install 18
  nvm install 20
  nvm install 22

maintenance: |
  nvm use

nvm use legge .nvmrc dalla directory radice della repo. Assicurati che il repository ne abbia uno (ad es., contenente 20).

Autenticazione nel browser (Playwright)

Devin mette a disposizione un browser Chrome con un endpoint CDP su localhost:29229 durante le sessioni. Usa script Playwright per automatizzare il login nel browser.

Il browser è disponibile solo durante le sessioni, non nelle build snapshot. Installa Playwright in initialize e conserva gli script di login nella tua repo.

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

Esempio di script di accesso (scripts/login.py):

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")

Conserva le credenziali di accesso come secrets, non nel codice sorgente. Per un’autenticazione a lungo termine, esegui il commit degli script di accesso in .agents/skills/ in modo che Devin possa riautenticarsi automaticamente.

Strumenti di sistema personalizzati e PATH

Installa pacchetti di sistema, binari personalizzati e configura il PATH in initialize.

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

GitHub Actions per configurare gli strumenti

Devin supporta l’esecuzione diretta di GitHub Actions nella sezione initialize di un blueprint. Questo è utile per installare versioni specifiche degli strumenti tramite le stesse azioni usate dalla tua CI.

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

Azioni come setup-node e setup-python modificano il PATH e le variabili d’ambiente. I binari installati da un’azione sono disponibili in tutti i passaggi successivi e in maintenance. Le azioni Node.js e quelle composite sono supportate; le azioni Docker sono supportate solo nelle build Linux. I passaggi uses non possono essere eseguiti in maintenance. Vedi limitazioni delle GitHub Actions.

Non servono GitHub Actions per la configurazione di base degli strumenti. I comandi shell diretti (nvm install 20, curl ... | sh, apt-get install) funzionano altrettanto bene e spesso sono più semplici. Le GitHub Actions sono particolarmente utili quando vuoi replicare esattamente la configurazione della tua CI o sfruttare la comodità di azioni come setup-java, che gestiscono più distribuzioni.

Proxy inverso HTTPS locale per più app

Esegui più servizi dietro hostname dall’aspetto realistico su HTTPS, come app.example.com, api.example.com e admin.example.com. Installa un singolo proxy inverso in initialize e instrada ogni hostname verso una porta upstream locale diversa.Caddy gestisce il routing e il TLS locale in un unico strumento. Un Caddyfile associa ogni hostname a un upstream e tls internal emette automaticamente un certificato attendibile per ciascun hostname dalla CA integrata di Caddy. caddy trust installa la root di quella CA nell’archivio di attendibilità del sistema e, aggiungendo la stessa root al database NSS, il browser la accetterà.Carica il Caddyfile tramite la sezione File allegati dell’editor del blueprint; sarà quindi disponibile come $FILE_CADDYFILE.

Caddyfile

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
}

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

Il loop di /etc/hosts è ciò che consente a app.example.com di risolversi in 127.0.0.1 all’interno della sessione. Aggiungi una voce per ogni hostname che inserisci nel Caddyfile.

Per aggiungere un servizio, aggiungi un blocco di tre righe al Caddyfile e una voce al loop di /etc/hosts, quindi apri il relativo hostname tramite HTTPS. Caddy genera un certificato alla prima richiesta, quindi non è necessario generare certificati separati per ogni app.

Esempi full-stack

Questi esempi mostrano come si combinano le configurazioni Enterprise e quelle a livello di org. In pratica, le divideresti tra diversi ambiti. Qui sono riunite a scopo di riferimento.

Stack Enterprise completo (Artifactory)

Un ambiente enterprise completo: certificato CA aziendale, proxy, Java (Maven), Python (pip/uv), Node.js (npm) e Docker, tutti puntati a una singola istanza di Artifactory.

Segreti richiesti

Rete e attendibilità (per l’intero account):

CORP_ROOT_CA_B64 — certificato CA aziendale codificato in Base64
CORP_HTTP_PROXY — URL del proxy HTTP
CORP_HTTPS_PROXY — URL del proxy HTTPS
CORP_NO_PROXY — host da escludere dal proxy

Credenziali del registry (per l’intera org):

ARTIFACTORY_USER — nome utente Artifactory
ARTIFACTORY_TOKEN — token API o password di Artifactory
ARTIFACTORY_MAVEN_URL — URL del repository Maven (ad es., https://artifactory.example.com/artifactory/maven-virtual)
ARTIFACTORY_PYPI_URL — URL del repository PyPI (ad es., https://user:token@artifactory.example.com/artifactory/api/pypi/pypi-virtual/simple)
ARTIFACTORY_NPM_URL — URL del repository npm (ad es., https://artifactory.example.com/artifactory/api/npm/npm-virtual)
ARTIFACTORY_DOCKER_URL — URL del registry Docker (ad es., artifactory.example.com)

In genere questo verrebbe suddiviso in tre ambiti:

A livello di account (initialize): Certificato e proxy
Org-wide (initialize): Installazione del runtime del linguaggio
A livello di org (maintenance): configurazione del registry contenente riferimenti letterali
Comandi di sessione: fornire esplicitamente i segreti, caricare l’environment setup ed effettuare il login per singole operazioni Docker

Di seguito il codice completo per riferimento:

initialize:
  # ── Account-wide: rete e attendibilità ──────────────────────────────────────

  - 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

  # ── Org-wide: language runtimes ──────────────────────────────────────────

  - 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:
  # ── Org-wide: configurazione del registry ───────────────────────────────────

  - 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"
        )

In questo esempio, tutti i registry puntano alla stessa istanza di Artifactory, ma utilizzano percorsi URL diversi. Ogni ecosistema di pacchetti ha il proprio formato di endpoint. Gli URL di Maven, PyPI, npm e Docker sono tutti diversi, anche per lo stesso registry.

Multilingua con registry diversi

Quando linguaggi diversi usano registry privati diversi (ad es. Maven da Nexus, npm da GitHub Packages, Python da Artifactory).

Segreti richiesti

NEXUS_MAVEN_URL — URL del repository Maven di Nexus
NEXUS_USER — nome utente di Nexus
NEXUS_PASS — password di Nexus
GITHUB_PACKAGES_TOKEN — token di accesso personale di GitHub con ambito read:packages
ARTIFACTORY_USER — nome utente di Artifactory
ARTIFACTORY_TOKEN — token API di Artifactory

Collega il tuo Git provider e concedi l’accesso ai repository che ospitano i moduli Go tramite le integrazioni Git.

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 (con ambito)
  - 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 → moduli privati tramite il Git provider collegato
  - 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

Ambiente isolato dalla rete con mirror privati

In un ambiente completamente air-gapped, Devin non può accedere ad alcun URL pubblico. Tutti gli strumenti, i runtime e i pacchetti devono provenire da mirror interni.

Segreti richiesti

Certificati:

CORP_ROOT_CA_B64 — certificato CA aziendale codificato in Base64

Accesso ai mirror:

APT_MIRROR_URL — URL del mirror APT interno di Ubuntu
MIRROR_USER — nome utente per l’autenticazione al mirror
MIRROR_PASS — password per l’autenticazione al mirror
JDK_TARBALL_URL — URL da cui scaricare il tarball JDK dal mirror interno
NODE_TARBALL_URL — URL da cui scaricare il tarball Node.js dal mirror interno

Registry dei pacchetti:

INTERNAL_MAVEN_URL — URL del registry Maven interno
INTERNAL_NPM_URL — URL del registry npm interno
INTERNAL_PYPI_URL — URL del registry PyPI interno

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: |
      # Scarica il tarball JDK dall'archivio artefatti interno
      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

Negli ambienti air-gapped, tutti gli strumenti necessari a Devin (runtime dei linguaggi di programmazione, strumenti CLI, ecc.) devono essere disponibili sui vostri mirror interni. I registry pubblici e i siti di download non sono raggiungibili.

VPN + certificati + proxy + linguaggi

Una configurazione Enterprise completa che combina strumenti VPN, certificati, configurazione del proxy e supporto multilingua. Il blueprint installa gli strumenti e memorizza la configurazione con riferimenti letterali. Connetti esplicitamente la VPN quando esegui operazioni che richiedono accesso interno.

Segreti richiesti

VPN:

VPN_CONFIG_B64 — file di configurazione OpenVPN codificato in Base64

Rete & attendibilità:

CORP_ROOT_CA_B64 — certificato CA aziendale codificato in Base64
CORP_HTTP_PROXY — URL del proxy HTTP
CORP_HTTPS_PROXY — URL del proxy HTTPS
CORP_NO_PROXY — host da escludere dal proxy

Credenziali del registry:

MAVEN_REGISTRY_URL — URL del registry Maven
NPM_REGISTRY_URL — URL del registry npm
PYPI_REGISTRY_HOST — hostname del registry PyPI
REGISTRY_USER — nome utente del registry (per Maven e pip)
REGISTRY_PASS — password del registry (per Maven e pip)
REGISTRY_TOKEN — token di autenticazione per npm

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 — risolve gli hostname interni
  - 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. Certificati — attendibilità delle CA interne
  - 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 — instrada il traffico attraverso il proxy aziendale
  - 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. Language runtimes
  - 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.

È richiesto l’accesso bootstrap. Il client OpenVPN deve essere preinstallato o installabile prima di stabilire il tunnel. VPN_CONFIG_B64 deve contenere certificati/chiavi inline, usare dev tun0 e connettersi senza authentication interattiva. I download dei runtime vengono eseguiti all’interno di un unico lifecycle del tunnel e caricano esplicitamente l’ambiente del proxy. Ripeti il block di setup/pulizia della VPN riportato in Rete e connettività per le operazioni di sessione; il blueprint non riconnette la VPN all’avvio della sessione.

Suggerimenti per scrivere blueprint efficaci

Prova prima i comandi in una sessione. Esegui i comandi manualmente in una sessione di Devin prima di aggiungerli al blueprint. È più veloce che aspettare un ciclo di build completo.
Usa initialize per gli strumenti da installare una sola volta, maintenance per le dipendenze. Tutto ciò che richiede minuti per essere installato (compilatori, binari di grandi dimensioni, strumenti globali) va in initialize. I comandi rapidi per le dipendenze (npm install, uv sync) vanno in maintenance.
Mantieni rapidi i comandi maintenance. Cerca di restare sotto i 2 minuti. Vengono eseguiti durante le build e vengono mostrati all’agente all’inizio della sessione.
Usa $ENVRC per le variabili d’ambiente non sensibili. Non scrivere credenziali o token derivati in $ENVRC, .bashrc o .profile. Carica esplicitamente la configurazione della shell che dipende dai segreti nel comando che ne ha bisogno.
Assegna un nome ai passaggi. La forma estesa con i campi name rende molto più semplice individuare gli errori nei log di build.
Usa le subshell per i monorepo. (cd packages/foo && npm install) viene eseguito in una subshell, così i passaggi successivi non risentono del cambio di directory.
Usa npm install, non npm ci. npm ci elimina node_modules e reinstalla tutto da zero, rallentando maintenance.
Usa i segreti del repo per i valori sensibili. Configurali nella scheda Segreti dell’editor del blueprint del repository invece di inserirli direttamente nei blueprint.

Per i dettagli sulla sintassi, consulta il riferimento del blueprint. Per risolvere gli errori di build, consulta Configurazione dichiarativa > Risoluzione dei problemi.

Get Started

Essential Guidelines

Onboarding Devin

Working with Devin

Product Guides

Integrations

Admin

Release Notes

Libreria di template dei blueprint di Devin

Guida rapida

Blueprint dei repository

Python

Node.js

Go

Java

Ruby on Rails

Rust

Monorepo

Private package registries

Registry Node.js

Registry Python

Registry JVM

Altri registry

Infrastruttura Enterprise

Rete e connettività

Identità e sicurezza

Configurazione del sistema

Pattern avanzati

Esempi full-stack

Suggerimenti per scrivere blueprint efficaci

​Guida rapida

​Blueprint dei repository

​Python

​Node.js

​Go

​Java

​Ruby on Rails

​Rust

​Monorepo

​Private package registries

​Registry Node.js

​Registry Python

​Registry JVM

​Altri registry

​Infrastruttura Enterprise

​Rete e connettività

​Identità e sicurezza

​Configurazione del sistema

​Pattern avanzati

​Esempi full-stack

​Suggerimenti per scrivere blueprint efficaci

Guida rapida

Blueprint dei repository

Python

Node.js

Go

Java

Ruby on Rails

Rust

Monorepo

Private package registries

Registry Node.js

Registry Python

Registry JVM

Altri registry

Infrastruttura Enterprise

Rete e connettività

Identità e sicurezza

Configurazione del sistema

Pattern avanzati

Esempi full-stack

Suggerimenti per scrivere blueprint efficaci