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

# Artefatos

> Conecte o Devin ao JFrog Artifactory, ao AWS CodeArtifact e ao Azure Artifacts adicionando credenciais e ferramentas de artefatos ao blueprint do seu ambiente.

Para usar artefatos durante os builds do snapshot, autentique-se nos seus repositórios de artefatos no [blueprint](https://docs.devinenterprise.com/pt-BR/onboard-devin/environment/blueprints.md) do seu ambiente.

Se precisar armazenar segredos para autenticação de artefatos, adicione-os na aba **Secrets** do editor de blueprint (consulte o [Gerenciador de Segredos do Devin](https://docs.devinenterprise.com/pt-BR/product-guides/secrets.md)) e faça referência a eles como `$VARIABLE_NAME` nas etapas do seu blueprint. Confira abaixo as seções para AWS, Azure e JFrog.

Se os seus artefatos estiverem em uma rede privada, consulte [Opções de deployment](https://docs.devinenterprise.com/pt-BR/enterprise/deployment/overview.md).

## Configuração do ambiente do Devin

Para integrar seus repositórios de artefatos, configure o ambiente do Devin com as credenciais e ferramentas adequadas. Há duas formas principais de fazer isso:

1. Inicie uma sessão do Devin e peça a ele que configure o próprio ambiente, incluindo as ferramentas e credenciais do seu repositório de artefatos. O Devin propõe um blueprint em forma de cartões de sugestão na linha do tempo da sessão; revise e aprove esses cartões para iniciar um build. Consulte [Deixe o Devin fazer isso](https://docs.devinenterprise.com/pt-BR/onboard-devin/environment/blueprints.md#getting-started).
2. Acesse **Configurações > Ambiente > Blueprints** e adicione os comandos de instalação e configuração da sua ferramenta de artefatos ao blueprint da organização ou ao blueprint de repositório. Ao salvar o blueprint, um build é iniciado. Consulte [Configuração manual](https://docs.devinenterprise.com/pt-BR/onboard-devin/environment/blueprints.md#getting-started).

Comandos executados diretamente no terminal de uma sessão não são mantidos no snapshot. Por isso, coloque a configuração de artefatos em um blueprint.

> [!NOTE]
>
> Os builds de blueprint são executados sem supervisão, portanto ninguém pode responder a prompts interativos. Os exemplos abaixo são comandos de terminal: antes de adicioná-los a um blueprint, adapte-os para versões não interativas e forneça as credenciais por meio dos segredos do blueprint.

## Jfrog Artifactory

### Etapa 1: Baixar a CLI

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

### Etapa 2: Baixar o artefato

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

# Defina as variáveis para sua instância do Artifactory e detalhes do artefato
ARTIFACTORY_URL="https://your-artifactory-instance.jfrog.io/artifactory"  # Altere isto para a URL do seu Artifactory
REPO="my-repository"  # Substitua pelo nome do seu repositório
ARTIFACT_PATH="my-artifact/my-package/1.0.0/my-package-1.0.0.jar"  # Caminho para o seu artefato no Artifactory
OUTPUT_DIR="./downloads"  # Diretório para salvar o artefato baixado

## Etapa 1: Fazer o download do artefato
echo "Fazendo download do artefato $ARTIFACT_PATH de $ARTIFACTORY_URL"
jfrog rt dl "$REPO/$ARTIFACT_PATH" "$OUTPUT_DIR/"

## Etapa 2: Verificar se o download foi bem-sucedido
if [ $? -eq 0 ]; then
  echo "Artefato baixado com sucesso em $OUTPUT_DIR/"
else
  echo "Falha ao fazer o download do artefato."
  exit 1
fi
```

## AWS CodeArtifact

### Etapa 1: Baixar a CLI

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

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

# Etapa 1: Criar role IAM para 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

# Verificar se o role IAM foi criado com sucesso
if [ $? -eq 0 ]; then
  echo "IAM Role $ROLE_NAME created successfully."
else
  echo "Failed to create IAM Role $ROLE_NAME."
  exit 1
fi

# Etapa 2: Anexar política ao role para acesso ao 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

# Etapa 3: Criar chaves de acesso IAM (para acesso programático)
echo "Creating Access Keys for IAM Role: $ROLE_NAME"
aws iam create-access-key \
  --user-name "$ROLE_NAME" \
  > access_keys_output.json

# Verificar se as chaves foram criadas
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

# Etapa 4: Exibir as informações do role IAM e da chave de acesso
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"
```

### Etapa 2: Download do artefato

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

# Variables
ARTIFACT_ID="example-artifact-id"  # Replace with the actual Artifact ID
# Passo 1: Obter a URL do Artifact para baixar o relatório
echo "Buscando URL de download do artifact para o ID do Artifact: $ARTIFACT_ID"
DOWNLOAD_URL=$(aws artifact describe-artifact \
  --artifact-id "$ARTIFACT_ID" \
  --query "artifactDetails[0].downloadUrl" \
  --output text)
```

## Azure Artifacts

### Etapa 1: Baixando a CLI

```bash theme={null}
# Instalar o repositório de pacotes da 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

# Atualizar as listas de pacotes e instalar o .NET SDK
sudo apt update
sudo apt install -y dotnet-sdk-8.0
dotnet tool install -g AzureArtifactsCredentialProvider
```

### Etapa 2: Gerando um PAT

Em seguida, você precisará gerar um token de acesso pessoal (PAT).

1. Faça login no seu [portal do Azure DevOps](https://dev.azure.com).
2. No canto superior direito, clique no seu perfil e selecione **Security**.
3. Na seção **Personal Access Tokens**, clique em **New Token**.
4. Defina os escopos do token. Você precisará de pelo menos o escopo **"Packaging (read)"** para acessar o Azure Artifacts.
5. Salve seu PAT com segurança, pois você não poderá visualizá-lo novamente.

### Etapa 3: Configure o arquivo .npmrc

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

Ao trabalhar com NuGet, você vai precisar do seguinte:

```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 você precisar de artefatos Docker do Azure:

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

> [!NOTE]
>
> Para começar a usar o Devin Enterprise, entre em contato com nossa [equipe de vendas Enterprise](mailto:enterprise@cognition.ai).


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