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

# Artefacts

> Accéder à vos artefacts

Pour utiliser des artefacts lors de la configuration d'un snapshot, vous devrez vous y authentifier pendant la configuration du dépôt.

Si vous devez stocker des secrets pour l'authentification aux artefacts, vous pouvez soit les enregistrer directement dans le système de fichiers de la machine (par exemple dans un fichier ou en exportant des variables d'environnement), soit utiliser le [Secret Manager de Devin](/fr/product-guides/secrets). Vous trouverez ci-dessous des sections pour AWS, Azure et JFrog.

Si vos artefacts se trouvent sur un réseau privé, veuillez consulter les [options de déploiement](/fr/enterprise/deployment/overview).

<div id="devin-machine-setup">
  ## Configuration de la machine Devin
</div>

Pour intégrer vos dépôts d’artefacts, vous devez configurer votre machine Devin avec les identifiants et les outils appropriés. Il existe deux principales façons de procéder :

1. Utiliser le Terminal intégré à Devin pour installer et configurer directement sur la machine les outils de dépôt d’artefacts.
2. Utiliser l’onglet **Setup Agent** (situé dans la colonne centrale de la machine Devin lors de la configuration du dépôt) et inviter Devin à vous assister dans cette configuration.

<Frame caption="Exemple d’utilisation du Terminal intégré pour la configuration d’un dépôt JFrog">
  <img src="https://mintcdn.com/cognitionai-enterprise/Z0RU7teHVwTGLph8/images/artifacts/Jfrog-repo-setup.png?fit=max&auto=format&n=Z0RU7teHVwTGLph8&q=85&s=41ec3c0e7807acc7bbb29e96e598baae" alt="Example of using Jfrog Repo Setup" width="3534" height="1992" data-path="images/artifacts/Jfrog-repo-setup.png" />
</Frame>

<div id="jfrog-artifactory">
  ## JFrog Artifactory
</div>

### Étape 1 : Téléchargement du CLI

```bash theme={null}
curl -fL https://getcli.jfrog.io | sh
sudo mv jfrog /usr/local/bin/
jfrog config add
jfrog rt config
```

<div id="step-2-download-artifact">
  ### Étape 2 : Téléchargez l’artefact
</div>

```bash theme={null}
#!/bin/bash

# Définir les variables pour votre instance Artifactory et les détails de l'artefact
ARTIFACTORY_URL="https://your-artifactory-instance.jfrog.io/artifactory"  # Modifier avec votre URL Artifactory
REPO="my-repository"  # Remplacer par le nom de votre dépôt
ARTIFACT_PATH="my-artifact/my-package/1.0.0/my-package-1.0.0.jar"  # Chemin vers votre artefact dans Artifactory
OUTPUT_DIR="./downloads"  # Répertoire pour enregistrer l'artefact téléchargé

## Étape 1 : Télécharger l'artefact
echo "Téléchargement de l'artefact $ARTIFACT_PATH depuis $ARTIFACTORY_URL"
jfrog rt dl "$REPO/$ARTIFACT_PATH" "$OUTPUT_DIR/"

## Étape 2 : Vérifier si le téléchargement a réussi
if [ $? -eq 0 ]; then
  echo "Artefact téléchargé avec succès dans $OUTPUT_DIR/"
else
  echo "Échec du téléchargement de l'artefact."
  exit 1
fi
```

<div id="aws-code-artifact">
  ## AWS CodeArtifact
</div>

<div id="step-1-downloading-cli">
  ### Étape 1 : Téléchargement de la CLI
</div>

```bash theme={null}
#!/bin/bash

# Variables
ROLE_NAME="robot-artifact-iam-role"
POLICY_ARN="arn:aws:iam::aws:policy/AWSArtifactReadOnlyAccess"
KEY_PAIR_NAME="robot-artifact-key-pair"

# Étape 1 : Créer le rôle IAM pour AWS Artifact
echo "Creating IAM Role: $ROLE_NAME"
aws iam create-role \
  --role-name "$ROLE_NAME" \
  --assume-role-policy-document '{
    "Version": "2012-10-17",
    "Statement": [
      {
        "Effect": "Allow",
        "Action": "sts:AssumeRole",
        "Principal": {
          "Service": "artifact.amazonaws.com"
        }
      }
    ]
  }' > create_role_output.json

# Vérifier si le rôle IAM a été créé avec succès
if [ $? -eq 0 ]; then
  echo "IAM Role $ROLE_NAME created successfully."
else
  echo "Failed to create IAM Role $ROLE_NAME."
  exit 1
fi

# Étape 2 : Attacher la politique au rôle pour l'accès à Artifact
echo "Attaching AWSArtifactReadOnlyAccess policy to IAM Role $ROLE_NAME"
aws iam attach-role-policy \
  --role-name "$ROLE_NAME" \
  --policy-arn "$POLICY_ARN"

if [ $? -eq 0 ]; then
  echo "Policy attached successfully."
else
  echo "Failed to attach policy."
  exit 1
fi

# Étape 3 : Créer les clés d'accès IAM (pour l'accès programmatique)
echo "Creating Access Keys for IAM Role: $ROLE_NAME"
aws iam create-access-key \
  --user-name "$ROLE_NAME" \
  > access_keys_output.json

# Vérifier si les clés ont été créées
if [ $? -eq 0 ]; then
  echo "Access keys created successfully."
  ACCESS_KEY_ID=$(jq -r '.AccessKey.AccessKeyId' access_keys_output.json)
  SECRET_ACCESS_KEY=$(jq -r '.AccessKey.SecretAccessKey' access_keys_output.json)

  echo "Access Key ID: $ACCESS_KEY_ID"
  echo "Secret Access Key: $SECRET_ACCESS_KEY"
else
  echo "Failed to create access keys."
  exit 1
fi

# Étape 4 : Afficher les informations du rôle IAM et de la clé d'accès
echo "IAM Role $ROLE_NAME has been created with the policy: $POLICY_ARN"
echo "Access Key ID: $ACCESS_KEY_ID"
echo "Secret Access Key: $SECRET_ACCESS_KEY"
```

<div id="step-2-downloading-artifact">
  ### Étape 2 : Télécharger l’artefact
</div>

```bash theme={null}
#!/bin/bash

# Variables
ARTIFACT_ID="example-artifact-id"  # Remplacer par l'ID d'artefact réel
# Étape 1 : Récupérer l'URL de l'artefact pour télécharger le rapport
echo "Fetching artifact download URL for Artifact ID: $ARTIFACT_ID"
DOWNLOAD_URL=$(aws artifact describe-artifact \
  --artifact-id "$ARTIFACT_ID" \
  --query "artifactDetails[0].downloadUrl" \
  --output text)
```

<div id="azure-artifacts">
  ## Azure Artifacts
</div>

### Étape 1 : Télécharger le CLI

```bash theme={null}
# Installer le dépôt de packages Microsoft
wget https://packages.microsoft.com/config/ubuntu/$(lsb_release -rs)/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb
rm packages-microsoft-prod.deb

# Mettre à jour les listes de packages et installer le SDK .NET
sudo apt update
sudo apt install -y dotnet-sdk-8.0
dotnet tool install -g AzureArtifactsCredentialProvider
```

<div id="step-2-generating-a-pat">
  ### Étape 2 : Génération d’un PAT
</div>

Ensuite, vous devrez générer un jeton d’accès personnel (PAT).

1. Connectez-vous à votre [portail Azure DevOps](https://dev.azure.com).
2. Dans le coin supérieur droit, cliquez sur votre profil et sélectionnez **Security**.
3. Dans la section **Personal Access Tokens**, cliquez sur **New Token**.
4. Définissez les autorisations pour le jeton. Vous aurez besoin au minimum de l’autorisation **« Packaging (read) »** pour accéder à Azure Artifacts.
5. Enregistrez votre PAT de manière sécurisée, car vous ne pourrez plus l’afficher par la suite.

<div id="step-3-configure-npmrc-file">
  ### Étape 3 : Configurer le fichier .npmrc
</div>

```bash theme={null}
echo "//pkgs.dev.azure.com/your-organization-name/_packaging/your-feed-name/npm/registry/:username=AzureDevOps" >> ~/.npmrc
echo "//pkgs.dev.azure.com/your-organization-name/_packaging/your-feed-name/npm/registry/:_password=$(echo -n your-PAT | base64)" >> ~/.npmrc
```

Si vous utilisez NuGet, vous aurez besoin des éléments suivants :

```bash theme={null}
mkdir -p ~/.nuget
cat <<EOL > ~/.nuget/nuget.config
<configuration>
  <packageSources>
    <add key="Azure Artifacts" value="https://pkgs.dev.azure.com/your-organization-name/_packaging/your-feed-name/nuget/v3/index.json" />
  </packageSources>
  <packageSourceCredentials>
    <Azure_Artifacts>
      <add key="Username" value="AzureDevOps" />
      <add key="ClearTextPassword" value="your-PAT" />
    </Azure_Artifacts>
  </packageSourceCredentials>
</configuration>
EOL
```

Si vous avez besoin d’artefacts Docker à partir d’Azure :

```bash theme={null}
echo your-PAT | docker login https://your-organization-name.azurecr.io --username your-username --password-stdin
```

<Note>
  Pour démarrer avec Devin Enterprise, contactez notre [équipe commerciale Enterprise](mailto:enterprise@cognition.ai).
</Note>