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

# Artefakte

> Zugriff auf Ihre Artefakte

Um Artefakte während der Snapshot-Einrichtung zu verwenden, müssen Sie sich im Rahmen der Repository-Konfiguration gegenüber diesen authentifizieren.

Wenn Sie Secrets für die Artefakt-Authentifizierung speichern müssen, können Sie diese entweder direkt im Dateisystem der Maschine ablegen (z. B. in einer Datei oder durch Export von Umgebungsvariablen) oder den [Devin Secret Manager](/de/product-guides/secrets) verwenden. Unten finden Sie Abschnitte für AWS, Azure und JFrog.

Wenn sich Ihre Artefakte in einem privaten Netzwerk befinden, lesen Sie bitte die Informationen zu den [Bereitstellungsoptionen](/de/enterprise/deployment/overview).

<div id="devin-machine-setup">
  ## Einrichtung der Devin-Maschine
</div>

Um Ihre Artefakt-Repositorys zu integrieren, müssen Sie Ihre Devin-Maschine mit den entsprechenden Anmeldedaten und Tools konfigurieren. Dazu gibt es zwei Hauptmöglichkeiten:

1. Verwenden Sie das integrierte Terminal von Devin, um Tools für Artefakt-Repositorys direkt auf der Maschine zu installieren und zu konfigurieren.
2. Verwenden Sie die Registerkarte **Setup Agent** (befindet sich in der mittleren Spalte der Devin-Maschine während der Repository-Einrichtung) und fordern Sie Devin auf, bei der Einrichtung zu helfen.

<Frame caption="Beispiel für die Verwendung des integrierten Terminals für die JFrog-Repository-Einrichtung">
  <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="Beispiel für die Verwendung der JFrog-Repository-Einrichtung" width="3534" height="1992" data-path="images/artifacts/Jfrog-repo-setup.png" />
</Frame>

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

<div id="step-1-downloading-cli">
  ### Schritt 1: CLI herunterladen
</div>

```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">
  ### Schritt 2: Artefakt herunterladen
</div>

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

# Variablen für Ihre Artifactory-Instanz und Artefaktdetails festlegen
ARTIFACTORY_URL="https://your-artifactory-instance.jfrog.io/artifactory"  # Ändern Sie dies in Ihre Artifactory-URL
REPO="my-repository"  # Ersetzen Sie dies durch Ihren Repository-Namen
ARTIFACT_PATH="my-artifact/my-package/1.0.0/my-package-1.0.0.jar"  # Pfad zu Ihrem Artefakt in Artifactory
OUTPUT_DIR="./downloads"  # Verzeichnis zum Speichern des heruntergeladenen Artefakts

## Schritt 1: Artefakt herunterladen
echo "Lade Artefakt $ARTIFACT_PATH von $ARTIFACTORY_URL herunter"
jfrog rt dl "$REPO/$ARTIFACT_PATH" "$OUTPUT_DIR/"

## Schritt 2: Prüfen, ob der Download erfolgreich war
if [ $? -eq 0 ]; then
  echo "Artefakt erfolgreich nach $OUTPUT_DIR/ heruntergeladen"
else
  echo "Fehler beim Herunterladen des Artefakts."
  exit 1
fi
```

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

<div id="step-1-downloading-cli">
  ### Schritt 1: CLI herunterladen
</div>

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

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

# Schritt 1: IAM-Rolle für AWS Artifact erstellen
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

# Prüfen, ob die IAM-Rolle erfolgreich erstellt wurde
if [ $? -eq 0 ]; then
  echo "IAM Role $ROLE_NAME created successfully."
else
  echo "Failed to create IAM Role $ROLE_NAME."
  exit 1
fi

# Schritt 2: Richtlinie an Rolle für Artifact-Zugriff anhängen
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

# Schritt 3: IAM-Zugriffsschlüssel erstellen (für programmatischen Zugriff)
echo "Creating Access Keys for IAM Role: $ROLE_NAME"
aws iam create-access-key \
  --user-name "$ROLE_NAME" \
  > access_keys_output.json

# Prüfen, ob die Schlüssel erstellt wurden
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

# Schritt 4: Informationen zu IAM-Rolle und Zugriffsschlüsseln anzeigen
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">
  ### Schritt 2: Herunterladen des Artefakts
</div>

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

# Variables
ARTIFACT_ID="example-artifact-id"  # Ersetzen Sie dies durch die tatsächliche Artifact-ID
# Step 1: Get Artifact URL for downloading the 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">
  ### Schritt 1: CLI herunterladen
</div>

```bash theme={null}
# Microsoft-Paket-Repository installieren
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

# Paketlisten aktualisieren und .NET SDK installieren
sudo apt update
sudo apt install -y dotnet-sdk-8.0
dotnet tool install -g AzureArtifactsCredentialProvider
```

<div id="step-2-generating-a-pat">
  ### Schritt 2: Generieren eines PAT
</div>

Als Nächstes müssen Sie ein persönliches Zugriffstoken (PAT) generieren.

1. Melden Sie sich beim [Azure DevOps-Portal](https://dev.azure.com) an.
2. Klicken Sie oben rechts auf Ihr Profil und wählen Sie **Security**.
3. Klicken Sie im Bereich **Personal Access Tokens** auf **New Token**.
4. Legen Sie die Scopes für das Token fest. Sie benötigen mindestens den Scope **"Packaging (read)"**, um auf Azure Artifacts zuzugreifen.
5. Speichern Sie Ihr PAT sicher, da Sie es später nicht noch einmal einsehen können.

<div id="step-3-configure-npmrc-file">
  ### Schritt 3: .npmrc-Datei konfigurieren
</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
```

Wenn Sie mit NuGet arbeiten, benötigen Sie Folgendes:

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

Wenn Sie Docker-Artefakte von Azure benötigen:

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

<Note>
  Um mit Devin Enterprise zu beginnen, wenden Sie sich an unser [Vertriebsteam für Enterprise-Kunden](mailto:enterprise@cognition.ai).
</Note>