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

# Artefatti

> Accesso ai tuoi artefatti

Per utilizzare gli artefatti durante la configurazione dello snapshot, dovrai autenticarti con essi durante la configurazione del repository.

Se devi archiviare segreti per l'autenticazione degli artefatti, puoi salvarli direttamente nel file system della macchina (ad esempio in un file o esportando variabili d'ambiente) oppure utilizzare il [Secret Manager di Devin](/it/product-guides/secrets). Di seguito trovi le sezioni su AWS, Azure e JFrog.

Se i tuoi artefatti si trovano su una rete privata, consulta [Opzioni di distribuzione](/it/enterprise/deployment/overview)

<div id="devin-machine-setup">
  ## Configurazione della macchina Devin
</div>

Per integrare Devin con i tuoi repository di artifact, devi configurare la tua macchina Devin con le credenziali e gli strumenti appropriati. Ci sono due modi principali per farlo:

1. Usa il terminale integrato in Devin per installare e configurare direttamente sulla macchina gli strumenti per i repository di artifact.
2. Usa la scheda **Setup Agent** (situata nella colonna centrale della macchina Devin durante la configurazione del repository) e chiedi a Devin di assisterti nella configurazione.

<Frame caption="Esempio di utilizzo del terminale integrato per la configurazione del repository 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>

### Passaggio 1: Scarica la 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">
  ### Passaggio 2: Scarica l'artifact
</div>

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

# Imposta le variabili per l'istanza Artifactory e i dettagli dell'artifact
ARTIFACTORY_URL="https://your-artifactory-instance.jfrog.io/artifactory"  # Modifica con l'URL della tua istanza Artifactory
REPO="my-repository"  # Sostituisci con il nome del repository
ARTIFACT_PATH="my-artifact/my-package/1.0.0/my-package-1.0.0.jar"  # Percorso dell'artifact in Artifactory
OUTPUT_DIR="./downloads"  # Directory in cui salvare l'artifact scaricato

## Passaggio 1: Download dell'artifact
echo "Download dell'artifact $ARTIFACT_PATH da $ARTIFACTORY_URL in corso"
jfrog rt dl "$REPO/$ARTIFACT_PATH" "$OUTPUT_DIR/"

## Passaggio 2: Verifica del successo del download
if [ $? -eq 0 ]; then
  echo "Artifact scaricato correttamente in $OUTPUT_DIR/"
else
  echo "Download dell'artifact non riuscito."
  exit 1
fi
```

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

<div id="step-1-downloading-cli">
  ### Passaggio 1: Scaricare la CLI
</div>

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

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

# Passaggio 1: Creare il ruolo IAM per 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

# Verificare se il ruolo IAM è stato creato correttamente
if [ $? -eq 0 ]; then
  echo "IAM Role $ROLE_NAME created successfully."
else
  echo "Failed to create IAM Role $ROLE_NAME."
  exit 1
fi

# Passaggio 2: Associare la policy al ruolo per l'accesso ad 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

# Passaggio 3: Creare le chiavi di accesso IAM (per l'accesso programmatico)
echo "Creating Access Keys for IAM Role: $ROLE_NAME"
aws iam create-access-key \
  --user-name "$ROLE_NAME" \
  > access_keys_output.json

# Verificare se le chiavi sono state create
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

# Passaggio 4: Visualizzare le informazioni sul ruolo IAM e sulle chiavi di accesso
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">
  ### Passaggio 2: Download dell'artifact
</div>

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

# Variabili
ARTIFACT_ID="example-artifact-id"  # Sostituire con l'ID Artifact reale
# Passaggio 1: GET dell'URL Artifact per scaricare il report
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>

<div id="step-1-downloading-cli">
  ### Passaggio 1: Scaricare la CLI
</div>

```bash theme={null}
# Install Microsoft package repository
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

# Aggiorna l'elenco dei pacchetti e installa .NET SDK
sudo apt update
sudo apt install -y dotnet-sdk-8.0
dotnet tool install -g AzureArtifactsCredentialProvider
```

<div id="step-2-generating-a-pat">
  ### Passaggio 2: Generazione di un PAT
</div>

Ora dovrai generare un personal access token (PAT).

1. Accedi al tuo [portale Azure DevOps](https://dev.azure.com).
2. Nell’angolo in alto a destra, fai clic sul tuo profilo e seleziona **Security**.
3. Nella sezione **Personal Access Tokens**, fai clic su **New Token**.
4. Configura gli ambiti (scope) del token. Avrai bisogno almeno dell’ambito **"Packaging (read)"** per accedere ad Azure Artifacts.
5. Salva il tuo PAT in modo sicuro, poiché non potrai più visualizzarlo.

<div id="step-3-configure-npmrc-file">
  ### Passaggio 3: Configura il file .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
```

Se lavori con NuGet, avrai bisogno dei seguenti elementi:

```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
```

Se ti servono artifact Docker da Azure:

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

<Note>
  Per iniziare a usare Devin Enterprise, contatta il nostro [team commerciale Enterprise](mailto:enterprise@cognition.ai).
</Note>