As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Usando o CodeArtifact com Maven O formato do repositório Maven é usado por várias linguagens diferentes, incluindo Java, Kotlin, Scala e Clojure. Ele é compatível com várias ferramentas de construção diferentes, incluindo Maven, Gradle, Scala SBT, Apache Ivy e Leiningen. Testamos e confirmamos a compatibilidade com o CodeArtifact para as seguintes versões: + Versão mais recente do **Maven**: 3.6.3. + A versão mais recente do **Gradle**: 6.4.1. 5.5.1 também foi testada. + A versão mais recente do **Clojure**: 1.11.1 também foi testada. **Topics** + [Usar o CodeArtifact com o Gradle](maven-gradle.md) + [Use CodeArtifact com mvn](maven-mvn.md) + [Usar o CodeArtifact com deps.edn](maven-deps.md) + [Publicar com curl](maven-curl.md) + [Usar somas de verificação do Maven](maven-checksums.md) + [Usar snapshot do Maven](maven-snapshots.md) + [Solicitação de pacotes Maven de upstreams e conexões externas](maven-upstream-external-connections-request.md) + [Solução de problemas do Maven](maven-troubleshooting.md) # Usar o CodeArtifact com o Gradle Depois que o token de autenticação do CodeArtifact estiver em uma variável de ambiente, conforme descrito em [Passar um token de autenticação usando uma variável de ambiente](tokens-authentication.md#env-var), siga estas instruções para consumir pacotes Maven e publicar novos pacotes em um repositório do CodeArtifact. **Topics** + [Buscar dependências](#fetching-dependencies) + [Buscar plug-ins](#fetching-plugins) + [Publicar artefatos](#publishing-artifacts) + [Executar uma compilação do Gradle no IntelliJ IDEA](#gradle-intellij) ## Buscar dependências Para buscar dependências do CodeArtifact em uma compilação do Gradle, use o procedimento a seguir. **Para buscar dependências do CodeArtifact em uma compilação do Gradle** 1. Caso contrário, crie e armazene um token de autorização do CodeArtifact em uma variável de ambiente seguindo o procedimento em [Passar um token de autenticação usando uma variável de ambiente](tokens-authentication.md#env-var). 1. Adicione uma seção `maven` à seção `repositories` no arquivo `build.gradle` do projeto. ``` maven { url 'https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/' credentials { username "aws" password System.env.CODEARTIFACT_AUTH_TOKEN } } ``` O `url` exemplo anterior é o endpoint do seu repositório do CodeArtifact. O Gradle usa o endpoint para se conectar ao repositório. No exemplo, `my_domain` é o nome do seu domínio; `111122223333`, o ID do proprietário do domínio e `my_repo`, o nome do seu repositório. Você pode recuperar o endpoint de um repositório usando o comando `get-repository-endpoint` AWS CLI. Por exemplo, com um repositório chamado *my\$1repo* dentro de um domínio chamado *my\$1domain*, o comando é o seguinte: ``` aws codeartifact get-repository-endpoint --domain my_domain --domain-owner 111122223333 --repository my_repo --format maven ``` O comando `get-repository-endpoint` retornará o endpoint do repositório: ``` url 'https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/' ``` O objeto `credentials` no exemplo anterior inclui o token de autorização do CodeArtifact criado na Etapa 1, que o Gradle usa para se autenticar no CodeArtifact. **nota** Para usar um endpoint de pilha dupla, use o endpoint `codeartifact.region.on.aws`. 1. (Opcional) - Para usar o repositório do CodeArtifact como a única fonte para as dependências do seu projeto, remova todas as outras seções de `repositories` `build.gradle`. Se você tiver mais de um repositório, o Gradle pesquisará dependências em cada repositório, na ordem em que estão listadas. 1. Depois de configurar o repositório, você pode adicionar dependências do projeto à seção `dependencies` com a sintaxe padrão do Gradle. ``` dependencies { implementation 'com.google.guava:guava:27.1-jre' implementation 'commons-cli:commons-cli:1.4' testImplementation 'org.testng:testng:6.14.3' } ``` ## Buscar plug-ins Por padrão, o Gradle resolverá plug-ins do [Portal de plug-ins do Gradle](https://plugins.gradle.org/) público. Para extrair plug-ins de um repositório do CodeArtifact, use o procedimento a seguir. **Para extrair plug-ins de um repositório do CodeArtifact** 1. Caso contrário, crie e armazene um token de autorização do CodeArtifact em uma variável de ambiente seguindo o procedimento em [Passar um token de autenticação usando uma variável de ambiente](tokens-authentication.md#env-var). 1. Adicione um bloco `pluginManagement` ao seu arquivo `settings.gradle`. O bloco `pluginManagement` deve aparecer antes de qualquer outra declaração em `settings.gradle`; consulte o seguinte trecho: ``` pluginManagement { repositories { maven { name 'my_repo' url 'https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/' credentials { username 'aws' password System.env.CODEARTIFACT_AUTH_TOKEN } } } } ``` Isso garantirá que o Gradle resolva plug-ins do repositório especificado. O repositório deve ter um repositório upstream com uma conexão externa com o Portal de plug-ins do Gradle (por exemplo, `gradle-plugins-store`) para que os plug-ins do Gradle normalmente exigidos estejam disponíveis para a compilação. Para obter mais informações, consulte a [documentação do Gradle](https://docs.gradle.org/current/userguide/plugins.html#sec:custom_plugin_repositories). ## Publicar artefatos Esta seção descreve como publicar uma biblioteca Java criada com o Gradle em um repositório do CodeArtifact. Primeiro, adicione o plug-in `maven-publish` à seção `plugins` do arquivo `build.gradle` do projeto. ``` plugins { id 'java-library' id 'maven-publish' } ``` Em seguida, adicione uma seção `publishing` ao arquivo `build.gradle` do projeto. ``` publishing { publications { mavenJava(MavenPublication) { groupId = 'group-id' artifactId = 'artifact-id' version = 'version' from components.java } } repositories { maven { url 'https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/' credentials { username "aws" password System.env.CODEARTIFACT_AUTH_TOKEN } } } } ``` O plug-in `maven-publish` gera um arquivo POM com base no `groupId`, `artifactId` e `version` especificados na seção `publishing`. Depois que essas alterações em `build.gradle` forem concluídas, execute o comando a seguir para criar o projeto e carregá-lo no repositório. ``` ./gradlew publish ``` Use `list-package-versions` para verificar se o pacote foi publicado com sucesso. ``` aws codeartifact list-package-versions --domain my_domain --domain-owner 111122223333 --repository my_repo --format maven\ --namespace com.company.framework --package my-package-name ``` Exemplo de resultado: ``` { "format": "maven", "namespace": "com.company.framework", "package": "example", "versions": [ { "version": "1.0", "revision": "REVISION-SAMPLE-1-C7F4S5E9B772FC", "status": "Published" } ] } ``` Para obter mais informações, consulte os tópicos a seguir no site do Gradle: + [Criar bibliotecas Java](https://guides.gradle.org/building-java-libraries/) + [Publicar um projeto como um módulo](https://docs.gradle.org/current/userguide/publishing_setup.html) ## Executar uma compilação do Gradle no IntelliJ IDEA Você pode executar uma compilação do Gradle no IntelliJ IDEA que extraia dependências do CodeArtifact. Para se autenticar com o CodeArtifact, você precisa fornecer ao Gradle um token de autorização do CodeArtifact. Há três métodos para fornecer um token de autorização. + Método 1: armazenar o token de autorização em `gradle.properties`. Use esse método se você conseguir fazer a substituição ou adição ao conteúdo do arquivo `gradle.properties`. + Método 2: armazenar o token de autorização em um arquivo separado. Use esse método se você não quiser modificar o arquivo `gradle.properties`. + Método 3: gerar um novo token de autorização para cada execução usando `aws` como um script em linha no `build.gradle`. Use esse método se quiser que o script do Gradle busque um novo token a cada execução. O token não será armazenado no sistema de arquivos. ------ #### [ Token stored in gradle.properties ] **Método 1: armazenar o token de autorização em `gradle.properties`** **nota** O exemplo mostra o arquivo `gradle.properties` localizado em `GRADLE_USER_HOME`. 1. Atualize o arquivo `build.gradle` com o seguinte trecho: ``` repositories { maven { url 'https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/' credentials { username "aws" password "$codeartifactToken" } } } ``` 1. Para obter plug-ins do CodeArtifact, adicione um bloco `pluginManagement` ao arquivo `settings.gradle`. O bloco `pluginManagement` deve aparecer antes de qualquer outra declaração em `settings.gradle`. ``` pluginManagement { repositories { maven { name 'my_repo' url 'https://my_domain-111122223333.codeartifact.region.amazonaws.com/maven/my_repo/' credentials { username 'aws' password "$codeartifactToken" } } } } ``` 1. Obtenha um token de autorização do CodeArtifact: ``` export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token --domain my_domain --domain-owner 111122223333 --query authorizationToken --output text --profile profile-name` ``` 1. Grave o token de autorização no arquivo `gradle.properties`: ``` echo "codeartifactToken=$CODEARTIFACT_AUTH_TOKEN" > ~/.gradle/gradle.properties ``` ------ #### [ Token stored in separate file ] **Método 2: armazenar o token de autorização em um arquivo separado** 1. Atualize o arquivo `build.gradle` com o seguinte trecho: ``` def props = new Properties() file("file").withInputStream { props.load(it) } repositories { maven { url 'https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/' credentials { username "aws" password props.getProperty("codeartifactToken") } } } ``` 1. Para obter plug-ins do CodeArtifact, adicione um bloco `pluginManagement` ao arquivo `settings.gradle`. O bloco `pluginManagement` deve aparecer antes de qualquer outra declaração em `settings.gradle`. ``` pluginManagement { def props = new Properties() file("file").withInputStream { props.load(it) } repositories { maven { name 'my_repo' url 'https://my_domain-111122223333.codeartifact.region.amazonaws.com/maven/my_repo/' credentials { username 'aws' password props.getProperty("codeartifactToken") } } } } ``` 1. Obtenha um token de autorização do CodeArtifact: ``` export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token --domain my_domain --domain-owner 111122223333 --query authorizationToken --output text --profile profile-name` ``` 1. Grave o token de autorização no arquivo que foi especificado em seu arquivo `build.gradle`: ``` echo "codeartifactToken=$CODEARTIFACT_AUTH_TOKEN" > file ``` ------ #### [ Token generated for each run in build.gradle ] **Método 3: gerar um novo token de autenticação para cada execução usando `aws` como um script em linha no `build.gradle`** 1. Atualize o arquivo `build.gradle` com o seguinte trecho: ``` def codeartifactToken = "aws codeartifact get-authorization-token --domain my_domain --domain-owner 111122223333 --query authorizationToken --output text --profile profile-name".execute().text repositories { maven { url 'https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/' credentials { username "aws" password codeartifactToken } } } ``` 1. Para obter plug-ins do CodeArtifact, adicione um bloco `pluginManagement` ao arquivo `settings.gradle`. O bloco `pluginManagement` deve aparecer antes de qualquer outra declaração em `settings.gradle`. ``` pluginManagement { def codeartifactToken = "aws codeartifact get-authorization-token --domain my_domain --domain-owner 111122223333 --query authorizationToken --output text --profile profile-name".execute().text repositories { maven { name 'my_repo' url 'https://my_domain-111122223333.codeartifact.region.amazonaws.com/maven/my_repo/' credentials { username 'aws' password codeartifactToken } } } } ``` ------ # Use CodeArtifact com mvn É possível usar o comando `mvn` para executar compilações do Maven. Esta seção mostra como configurar `mvn` para usar um CodeArtifact repositório. **Topics** + [Buscar dependências](#fetching-dependencies) + [Publicar artefatos](#publishing-artifacts) + [Publicar artefatos de terceiros](#publishing-third-party-artifacts) + [Restringir downloads de dependências do Maven em um repositório CodeArtifact](#restrict-maven-downloads) + [Informações do Apache Maven Project](#apache-maven-project-info) ## Buscar dependências Para configurar `mvn` para buscar dependências de um CodeArtifact repositório, você deve editar o arquivo de configuração do Maven e, opcionalmente`settings.xml`, o POM do seu projeto. 1. Caso contrário, crie e armazene um token de CodeArtifact autenticação em uma variável de ambiente conforme descrito em [Passar um token de autenticação usando uma variável de ambiente](tokens-authentication.md#env-var) Para configurar a autenticação no seu CodeArtifact repositório. 1. Em `settings.xml` (geralmente encontrado em `~/.m2/settings.xml`), adicione uma seção `` com uma referência à variável de ambiente `CODEARTIFACT_AUTH_TOKEN` para que o Maven passe o token nas solicitações HTTP. ``` ... codeartifact aws ${env.CODEARTIFACT_AUTH_TOKEN} ... ``` 1. Adicione o endpoint de URL do seu CodeArtifact repositório em um `` elemento. Você pode fazer isso no `settings.xml` ou arquivo POM do seu projeto. Você pode recuperar o endpoint do seu repositório usando o comando. `get-repository-endpoint` AWS CLI Por exemplo, com um repositório nomeado *my\$1repo* dentro de um domínio chamado*my\$1domain*, o comando é o seguinte: ``` aws codeartifact get-repository-endpoint --domain my_domain --repository my_repo --format maven ``` O comando `get-repository-endpoint` retornará o endpoint do repositório: ``` url 'https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/' ``` **nota** Para usar um endpoint de pilha dupla, use o endpoint `codeartifact.region.on.aws`. Adicione o endpoint do repositório ao `settings.xml` da seguinte forma. ``` ... default codeartifact https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/ default ... ``` Ou você pode adicionar a `` seção a um arquivo POM do projeto CodeArtifact para usar somente nesse projeto. ``` ... codeartifact codeartifact https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/ ... ``` **Importante** Você pode usar qualquer valor no elemento ``, mas ele deve ser o mesmo nos elementos `` e ``. Isso permite que as credenciais especificadas sejam incluídas nas solicitações para CodeArtifact. Depois de fazer essas alterações na configuração, você pode criar o projeto. ``` mvn compile ``` O Maven registra o URL completo de todas as dependências que ele baixa para o console. ``` [INFO] ------------------< com.example.example:myapp >------------------- [INFO] Building myapp 1.0 [INFO] --------------------------------[ jar ]--------------------------------- Downloading from codeartifact: https://.d.codeartifact.us-west-2.amazonaws.com/maven/myrepo/commons-cli/commons-cli/1.4/commons-cli-1.4.pom Downloaded from codeartifact: https://.d.codeartifact.us-west-2.amazonaws.com/maven/myrepo/commons-cli/commons-cli/1.4/commons-cli-1.4.pom (11 kB at 3.9 kB/s) Downloading from codeartifact: https://.d.codeartifact.us-west-2.amazonaws.com/maven/myrepo/org/apache/commons/commons-parent/42/commons-parent-42.pom Downloading from codeartifact: https://.d.codeartifact.us-west-2.amazonaws.com/maven/myrepo/org/apache/commons/commons-parent/42/commons-parent-42.pom Downloaded from codeartifact: https://.d.codeartifact.us-west-2.amazonaws.com/maven/myrepo/org/apache/commons/commons-parent/42/commons-parent-42.pom (68 kB at 123 kB/s) Downloading from codeartifact: https://.d.codeartifact.us-west-2.amazonaws.com/maven/myrepo/commons-cli/commons-cli/1.4/commons-cli-1.4.jar Downloaded from codeartifact: https://.d.codeartifact.us-west-2.amazonaws.com/maven/myrepo/commons-cli/commons-cli/1.4/commons-cli-1.4.jar (54 kB at 134 kB/s) ``` ## Publicar artefatos Para publicar um artefato do Maven em um CodeArtifact repositório, você também deve editar o POM do `~/.m2/settings.xml` projeto. `mvn` 1. Caso contrário, crie e armazene um token de CodeArtifact autenticação em uma variável de ambiente conforme descrito em [Passar um token de autenticação usando uma variável de ambiente](tokens-authentication.md#env-var) Para configurar a autenticação no seu CodeArtifact repositório. 1. Adicione uma seção `` a `settings.xml` com uma referência à variável de ambiente `CODEARTIFACT_AUTH_TOKEN` para que o Maven passe o token nas solicitações HTTP. ``` ... codeartifact aws ${env.CODEARTIFACT_AUTH_TOKEN} ... ``` 1. Adicione uma seção `` ao `pom.xml` do seu projeto. ``` ... codeartifact codeartifact https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/ ... ``` Depois de fazer essas alterações na configuração, você pode criar o projeto e publicá-lo no repositório específico. ``` mvn deploy ``` Use `list-package-versions` para verificar se o pacote foi publicado com sucesso. ``` aws codeartifact list-package-versions --domain my_domain --domain-owner 111122223333 --repository my_repo --format maven \ --namespace com.company.framework --package my-package-name ``` Exemplo de saída: ``` { "defaultDisplayVersion": null, "format": "maven", "namespace": "com.company.framework", "package": "my-package-name", "versions": [ { "version": "1.0", "revision": "REVISION-SAMPLE-1-C7F4S5E9B772FC", "status": "Published" } ] } ``` ## Publicar artefatos de terceiros Você pode publicar artefatos Maven de terceiros em um CodeArtifact repositório com. `mvn deploy:deploy-file` Isso pode ser útil para usuários que desejam publicar artefatos e têm somente arquivos JAR e não têm acesso ao código-fonte do pacote ou aos arquivos POM. O comando `mvn deploy:deploy-file` gerará um arquivo POM com base nas informações passadas na linha de comando. **Publicar artefatos Maven de terceiros** 1. Caso contrário, crie e armazene um token de CodeArtifact autenticação em uma variável de ambiente conforme descrito em [Passar um token de autenticação usando uma variável de ambiente](tokens-authentication.md#env-var) Para configurar a autenticação no seu CodeArtifact repositório. 1. Crie um arquivo `~/.m2/settings.xml` com o seguinte conteúdo: ``` codeartifact aws ${env.CODEARTIFACT_AUTH_TOKEN} ``` 1. Execute o comando `mvn deploy:deploy-file`: ``` mvn deploy:deploy-file -DgroupId=commons-cli \ -DartifactId=commons-cli \ -Dversion=1.4 \ -Dfile=./commons-cli-1.4.jar \ -Dpackaging=jar \ -DrepositoryId=codeartifact \ -Durl=https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/repo-name/ ``` **nota** O exemplo acima publica `commons-cli 1.4`. Modifique os argumentos groupID, artifactID, version e file para publicar um JAR diferente. Essas instruções são baseadas em exemplos no [Guia para implantação de terceiros JARs em repositórios remotos](https://maven.apache.org/guides/mini/guide-3rd-party-jars-remote.html) da documentação do *Apache* Maven. ## Restringir downloads de dependências do Maven em um repositório CodeArtifact Se um pacote não puder ser obtido de um repositório configurado, por padrão, o `mvn` comando o buscará no Maven Central. Adicione o `mirrors` elemento para `settings.xml` fazer com que `mvn` sempre use seu CodeArtifact repositório. ``` ... central-mirror CodeArtifact Maven Central mirror https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/ central ... ``` Se você adicionar um elemento `mirrors`, você também deve ter um elemento `pluginRepository` em seu `settings.xml` ou `pom.xml`. O exemplo a seguir busca dependências de aplicativos e plug-ins do Maven de um repositório. CodeArtifact ``` ... codeartifact CodeArtifact Plugins https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/ true true ... ``` O exemplo a seguir busca dependências de aplicativos de um CodeArtifact repositório e busca plug-ins Maven do Maven Central. ``` default ... central-plugins Central Plugins https://repo.maven.apache.org/maven2/ true true .... ``` ## Informações do Apache Maven Project Para obter mais informações sobre o Maven, consulte esses tópicos no site do Apache Maven Project: + [Configurar vários repositórios](https://maven.apache.org/guides/mini/guide-multiple-repositories.html) + [Referência de configurações](https://maven.apache.org/settings.html) + [Gerenciamento de distribuição](https://maven.apache.org/pom.html#Distribution_Management) + [Perfis](https://maven.apache.org/pom.html#Profiles) # Usar o CodeArtifact com deps.edn É possível usar `deps.edn` com `clj` para gerenciar dependências para projetos do Clojure. Esta seção mostra como configurar o `deps.edn` para usar um repositório do CodeArtifact. **Topics** + [Buscar dependências](#fetching-dependencies-deps) + [Publicar artefatos](#publishing-artifacts-deps) ## Buscar dependências Para configurar o `Clojure` para buscar dependências de um repositório do CodeArtifact, você deve editar o arquivo de configuração do Maven, `settings.xml`. 1. Em `settings.xml`, adicione uma seção `` com uma referência à variável de ambiente `CODEARTIFACT_AUTH_TOKEN` para que o Clojure passe o token nas solicitações HTTP. **nota** O Clojure supõe que o arquivo settings.xml esteja localizado em `~/.m2/settings.xml`. Se estiver em outro lugar, crie o arquivo nesse local. ``` ... codeartifact aws ${env.CODEARTIFACT_AUTH_TOKEN} ... ``` 1. Se você ainda não tiver um, gere um POM xml para seu projeto usando `clj -Spom`. 1. No seu arquivo de configuração `deps.edn`, adicione um repositório que corresponda ao ID do servidor do Maven `settings.xml`. ``` :mvn/repos { "clojars" nil "central" nil "codeartifact" {:url "https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/"} } ``` **nota** `tools.deps` garante que os repositórios `central` e `clojars` sejam verificados primeiro para as bibliotecas do Maven. Depois disso, os outros repositórios listados em `deps.edn` serão verificados. Para evitar o download direto do Clojars e do Maven Central, `central` e `clojars` precisam ser configurados como `nil`. Verifique se você tem o token de autenticação do CodeArtifact em uma variável de ambiente (consulte [Passar um token de autenticação usando uma variável de ambiente](tokens-authentication.md#env-var)). Ao criar o pacote após essas alterações, as dependências em `deps.edn` serão obtidas do CodeArtifact. **nota** Para usar um endpoint de pilha dupla, use o endpoint `codeartifact.region.on.aws`. ## Publicar artefatos 1. Atualize suas configurações do Maven e `deps.edn` para incluir o CodeArtifact como um servidor reconhecido pelo Maven (consulte [Buscar dependências](#fetching-dependencies-deps)). Você pode usar uma ferramenta como [deps-deploy](https://github.com/slipset/deps-deploy) para fazer upload de artefatos no CodeArtifact. 1. No seu `build.clj`, adicione uma tarefa `deploy` para carregar os artefatos necessários no repositório `codeartifact` configurado anteriormente. ``` (ns build (:require [deps-deploy.deps-deploy :as dd])) (defn deploy [_] (dd/deploy {:installer :remote :artifact "PATH_TO_JAR_FILE.jar" :pom-file "pom.xml" ;; pom containing artifact coordinates :repository "codeartifact"})) ``` 1. Publique o artefato executando o comando: `clj -T:build deploy` Para obter mais informações sobre a modificação de repositórios padrão, consulte [Modificar repositórios padrão](https://clojure.org/reference/deps_and_cli#_modifying_the_default_repositories) no *Clojure Deps e Lógica da referência da CLI*. # Publicar com curl Esta seção mostra como usar o cliente HTTP `curl` para publicar artefatos do Maven em um repositório do CodeArtifact. A publicação de artefatos com `curl` pode ser útil se você não tiver ou quiser instalar o cliente Maven em seus ambientes. **Publicar um artefato do Maven com `curl`** 1. É possível buscar um token de autorização do CodeArtifact seguindo as etapas em [Passar um token de autenticação usando uma variável de ambiente](tokens-authentication.md#env-var) e voltar para essas etapas. 1. Use o seguinte comando `curl` para publicar o JAR em um repositório do CodeArtifact: Em cada um dos comandos `curl` desse procedimento, substitua os seguintes espaços reservados: + Substitua *my\$1domain* pelo seu nome de domínio do CodeArtifact. + Substitua *111122223333* pelo ID do proprietário do seu domínio do CodeArtifact. + Substitua *us-west-2* pela região na qual seu domínio do CodeArtifact está localizado. + Substitua *my\$1repo* pelo nome do seu repositório do CodeArtifact. ``` curl --request PUT https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/com/mycompany/app/my-app/1.0/my-app-1.0.jar \ --user "aws:$CODEARTIFACT_AUTH_TOKEN" --header "Content-Type: application/octet-stream" \ --data-binary @my-app-1.0.jar ``` **Importante** Você deve prefixar o valor do parâmetro `--data-binary` com um caractere `@`. Ao colocar o valor entre aspas, `@` deve ser incluído entre aspas. 1. Use o seguinte comando `curl` para publicar o POM em um repositório do CodeArtifact: ``` curl --request PUT https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/com/mycompany/app/my-app/1.0/my-app-1.0.pom \ --user "aws:$CODEARTIFACT_AUTH_TOKEN" --header "Content-Type: application/octet-stream" \ --data-binary @my-app-1.0.pom ``` 1. Nesse ponto, o artefato do Maven estará no seu repositório do CodeArtifact com o status de `Unfinished`. Para poder consumir o pacote, ele deve estar no estado `Published`. Você pode mover o pacote de `Unfinished` para `Published` fazendo o upload de um arquivo `maven-metadata.xml` em seu pacote ou chamando a [API UpdatePackageVersionsStatus](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html) para alterar o status. 1. Opção 1: use o comando `curl` a seguir para adicionar um arquivo `maven-metadata.xml` ao seu pacote: ``` curl --request PUT https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/com/mycompany/app/my-app/maven-metadata.xml \ --user "aws:$CODEARTIFACT_AUTH_TOKEN" --header "Content-Type: application/octet-stream" \ --data-binary @maven-metadata.xml ``` Um exemplo dos conteúdos em um arquivo `maven-metadata.xml` é mostrado a seguir: ``` com.mycompany.app my-app 1.0 1.0 1.0 20200731090423 ``` 1. Opção 2: atualize o status do pacote para `Published` com a API `UpdatePackageVersionsStatus`. ``` aws codeartifact update-package-versions-status \ --domain my_domain \ --domain-owner 111122223333 \ --repository my_repo \ --format maven \ --namespace com.mycompany.app \ --package my-app \ --versions 1.0 \ --target-status Published ``` Se você tiver apenas o arquivo JAR de um artefato, poderá publicar uma versão de pacote consumível em um repositório do CodeArtifact usando `mvn`. Isso pode ser útil se você não tiver acesso ao código-fonte do artefato ou ao POM. Para mais detalhes, consulte [Publicar artefatos de terceiros](maven-mvn.md#publishing-third-party-artifacts). # Usar somas de verificação do Maven Quando um artefato Maven é publicado em um AWS CodeArtifact repositório, a soma de verificação associada a cada *ativo* ou arquivo no pacote é usada para validar o upload. Os arquivos *jar*, *pom* e *war* são exemplos de ativos. Para cada ativo, o artefato do Maven contém vários arquivos de soma de verificação que usam o nome do ativo com uma extensão adicional, como `md5` ou `sha1`. Por exemplo, os arquivos de soma de verificação de um arquivo chamado `my-maven-package.jar` podem ser `my-maven-package.jar.md5` e `my-maven-package.jar.sha1`. **nota** O Maven usa o termo`artifact`. Neste guia, um pacote Maven é o mesmo que um artefato do Maven. Para obter mais informações, consulte o [AWS CodeArtifactpacote](https://docs.aws.amazon.com/codeartifact/latest/ug/welcome.html#welcome-concepts-package). ## Armazenamento da soma de verificação CodeArtifact não armazena somas de verificação do Maven como ativos. [Isso significa que as somas de verificação não aparecem como ativos individuais na saída da ListPackageVersionAssets API.](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersionAssets.html) Em vez disso, as somas de verificação calculadas por CodeArtifact estão disponíveis para cada ativo em todos os tipos de soma de verificação compatíveis. Por exemplo, parte da resposta da chamada ListPackageVersionAssets na versão do pacote Maven `commons-lang:commons-lang 2.1` é: ``` { "name": "commons-lang-2.1.jar", "size": 207723, "hashes": { "MD5": "51591549f1662a64543f08a1d4a0cf87", "SHA-1": "4763ecc9d78781c915c07eb03e90572c7ff04205", "SHA-256": "2ded7343dc8e57decd5e6302337139be020fdd885a2935925e8d575975e480b9", "SHA-512": "a312a5e33b17835f2e82e74ab52ab81f0dec01a7e72a2ba58bb76b6a197ffcd2bb410e341ef7b3720f3b595ce49fdd9994ea887ba08ff6fe21b2c714f8c405af" } }, { "name": "commons-lang-2.1.pom", "size": 9928, "hashes": { "MD5": "8e41bacdd69de9373c20326d231c8a5d", "SHA-1": "a34d992202615804c534953aba402de55d8ee47c", "SHA-256": "f1a709cd489f23498a0b6b3dfbfc0d21d4f15904791446dec7f8a58a7da5bd6a", "SHA-512": "1631ce8fe4101b6cde857f5b1db9b29b937f98ba445a60e76cc2b8f2a732ff24d19b91821a052c1b56b73325104e9280382b2520edda4e7696698165c7e09161" } }, { "name": "maven-metadata.xml", "size": 121, "hashes": { "MD5": "11bb3d48d984f2f49cea1e150b6fa371", "SHA-1": "7ef872be17357751ce65cb907834b6c5769998db", "SHA-256": "d04d140362ea8989a824a518439246e7194e719557e8d701831b7f5a8228411c", "SHA-512": "001813a0333ce4b2a47cf44900470bc2265ae65123a8c6b5ac5f2859184608596baa4d8ee0696d0a497755dade0f6bf5e54667215a06ceae1effdfb7a8d30f88" } } ``` Mesmo que as somas de verificação não sejam armazenadas como ativos, os clientes do Maven ainda podem publicar e baixar as somas de verificação nos locais esperados. Por exemplo, se `commons-lang:commons-lang 2.1` estivesse em um repositório chamado `maven-repo`, o caminho do URL para a soma de verificação SHA-256 do arquivo JAR seria: ``` /maven/maven-repo/commons-lang/commons-lang/2.1/commons-lang-2.1.jar.sha256 ``` Se você estiver fazendo o upload de pacotes Maven existentes (por exemplo, pacotes previamente armazenados no Amazon S3) CodeArtifact para usar um cliente HTTP genérico, `curl` como, por exemplo, não é necessário carregar as somas de verificação. CodeArtifact os gerará automaticamente. Se quiser verificar se os ativos foram carregados corretamente, você pode usar a operação da ListPackageVersionAssets API para comparar as somas de verificação na resposta com os valores originais de cada ativo. ## Incompatibilidades da soma de verificação durante a publicação Além dos ativos e das somas de verificação, os artefatos do Maven também contêm um arquivo `maven-metadata.xml`. A sequência normal de publicação de um pacote Maven é que todos os ativos e somas de verificação sejam carregados primeiro, seguidos por `maven-metadata.xml`. Por exemplo, a sequência de publicação da versão `commons-lang 2.1` do pacote Maven descrita anteriormente, supondo que o cliente tenha sido configurado para publicar arquivos da soma de verificação SHA-256, seria: ``` PUT commons-lang-2.1.jar PUT commons-lang-2.1.jar.sha256 PUT commons-lang-2.1.pom PUT commons-lang-2.1.pom.sha256 PUT maven-metadata.xml PUT maven-metadata.xml.sha256 ``` Ao carregar o arquivo de soma de verificação de um ativo, como um arquivo JAR, a solicitação de upload da soma de verificação falhará com uma resposta **400 (Solicitação inválida)** se houver uma incompatibilidade entre o valor da soma de verificação carregada e o valor da soma de verificação calculado por. CodeArtifact Se o ativo correspondente não existir, a solicitação falhará com a resposta **404 (Não encontrado)**. Para evitar esse erro, você deve primeiro carregar o ativo e, em seguida, fazer o upload da soma de verificação. Quando `maven-metadata.xml` é carregado, CodeArtifact normalmente muda o status da versão do pacote Maven de `Unfinished` para`Published`. Se uma incompatibilidade de soma de verificação for detectada para qualquer ativo, CodeArtifact retornará **400 (solicitação inválida)** em resposta à solicitação de `maven-metadata.xml` publicação. Esse erro pode impedir que o cliente faça upload de arquivos para essa versão do pacote. Se isso ocorrer e o arquivo `maven-metadata.xml` não for carregado, nenhum ativo da versão do pacote já carregado poderá ser baixado. Isso ocorre porque o status da versão do pacote não está definido como `Published` e permanece como `Unfinished`. CodeArtifact permite adicionar mais ativos a uma versão do pacote Maven mesmo após `maven-metadata.xml` o upload e o status da versão do pacote ter sido definido como. `Published` Nesse status, uma solicitação para carregar um arquivo de soma de verificação incompatível também falhará com uma resposta **400 (Solicitação inválida)**. No entanto, como o status da versão do pacote já foi definido como `Published`, você pode baixar qualquer ativo do pacote, incluindo aqueles para os quais o upload do arquivo de soma de verificação falhou. Ao baixar uma soma de verificação para um ativo em que o upload do arquivo de soma de verificação falhou, o valor da soma de verificação que o cliente receberá será o valor da soma de verificação calculado CodeArtifact com base nos dados do ativo carregado. CodeArtifact as comparações de somas de verificação diferenciam maiúsculas de minúsculas e as somas de verificação calculadas por CodeArtifact são formatadas em minúsculas. Portanto, se a soma de verificação `909FA780F76DA393E992A3D2D495F468` for carregada, ela falhará com uma incompatibilidade de soma de verificação porque CodeArtifact não a trata como igual a. `909fa780f76da393e992a3d2d495f468` ## Recuperação no caso de incompatibilidades da soma de verificação Se o upload de uma soma de verificação falhar como resultado de uma incompatibilidade, tente uma das seguintes opções de recuperação: + Execute o comando que publica o artefato do Maven novamente. Isso pode funcionar se um problema de rede tiver corrompido o arquivo de soma de verificação. Se isso resolver o problema de rede, a soma de verificação será correspondente e o download será concluído. + Exclua a versão do pacote e, em seguida, faça uma nova publicação. Para obter mais informações, consulte [DeletePackageVersions](https://docs.aws.amazon.com/dms/latest/APIReference/API_DeletePackageVersions.html)a *AWS CodeArtifact API Reference*. # Usar snapshot do Maven Um *snapshot* do Maven é uma versão especial de um pacote do Maven que se refere ao código de ramificação de produção mais recente. É uma versão de desenvolvimento que precede a versão final de lançamento. Você pode identificar a versão de snapshot de um pacote do Maven pelo sufixo `SNAPSHOT` anexado à versão do pacote. Por exemplo, o snapshot da versão `1.1` é `1.1-SNAPSHOT`. Para obter mais informações, consulte [O que é uma versão de SNAPSHOT?](https://maven.apache.org/guides/getting-started/index.html#What_is_a_SNAPSHOT_version) no site do Apache Maven Project. AWS CodeArtifact suporta a publicação e o consumo de instantâneos do Maven. Instantâneos exclusivos que usam um número de versão baseado em tempo são os únicos instantâneos compatíveis. CodeArtifact não suporta instantâneos não exclusivos que são gerados por clientes Maven 2. Você pode publicar um snapshot compatível do Maven em qualquer CodeArtifact repositório. **Topics** + [Publicação de instantâneos em CodeArtifact](#maven-snapshot-publishing) + [Consumir versões de snapshot](#maven-consuming-snapshot-versions) + [Excluir versões de snapshot](#maven-deleting-snapshot-versions) + [Publicação de snapshot com curl](#maven-snapshot-publishing-curl) + [Snapshots e conexões externas](#maven-snapshot-external-connections) + [Snapshots e repositórios upstream](#maven-snapshot-upstream-repositories) ## Publicação de instantâneos em CodeArtifact AWS CodeArtifact suporta os padrões de solicitação que os clientes, por exemplo`mvn`, usam ao publicar instantâneos. Por isso, você pode seguir a documentação da sua ferramenta de compilação ou gerenciador de pacotes sem ter uma compreensão detalhada de como os snapshots do Maven são publicados. Se você estiver fazendo algo mais complexo, esta seção descreve em detalhes como CodeArtifact lidar com instantâneos. Quando um snapshot do Maven é publicado em um CodeArtifact repositório, sua versão anterior é preservada em uma nova versão chamada compilação. Cada vez que um snapshot do Maven é publicado, uma nova versão de compilação é criada. Todas as versões anteriores de um snapshot são mantidas em suas versões de compilação. Quando um snapshot do Maven é publicado, o status da versão do pacote é definido como `Published` e o status da compilação que contém a versão anterior é definido como `Unlisted`. Esse comportamento se aplica somente às versões do pacote Maven onde o sufixo é `-SNAPSHOT`. Por exemplo, versões instantâneas de um pacote maven chamado `com.mycompany.myapp:pkg-1` são carregadas em um CodeArtifact repositório chamado. `my-maven-repo` A versão de snapshot é `1.0-SNAPSHOT`. Até o momento, nenhuma versão do `com.mycompany.myapp:pkg-1` foi publicada. Primeiro, os ativos da compilação inicial são publicados nos seguintes caminhos: ``` PUT maven/my-maven-repo/com/mycompany/myapp/pkg-1/1.0-SNAPSHOT/pkg-1-1.0-20210728.194552-1.jar PUT maven/my-maven-repo/com/mycompany/myapp/pkg-1/1.0-SNAPSHOT/pkg-1-1.0-20210728.194552-1.pom ``` Observe que o timestamp `20210728.194552-1` é gerado pelo cliente que publica as compilações do snapshot. Depois que os arquivos .pom e .jar forem carregados, a única versão do `com.mycompany.myapp:pkg-1` presente no repositório será `1.0-20210728.194552-1`. Isso acontece mesmo que a versão especificada no caminho anterior seja `1.0-SNAPSHOT`. O status da versão do pacote nesse momento é `Unfinished`. ``` aws codeartifact list-package-versions --domain my-domain --repository \ my-maven-repo --package pkg-1 --namespace com.mycompany.myapp --format maven { "versions": [ { "version": "1.0-20210728.194552-1", "revision": "GipMW+599JmwTcTLaXo9YvDsVQ2bcrrk/02rWJhoKUU=", "status": "Unfinished" } ], "defaultDisplayVersion": null, "format": "maven", "package": "pkg-1", "namespace": "com.mycompany.myapp" } ``` Em seguida, o cliente faz o upload do arquivo `maven-metadata.xml` para a versão do pacote: ``` PUT my-maven-repo/com/mycompany/myapp/pkg-1/1.0-SNAPSHOT/maven-metadata.xml ``` Quando o arquivo maven-metadata.xml é carregado com sucesso, CodeArtifact cria a versão do `1.0-SNAPSHOT` pacote e define a `1.0-20210728.194552-1` versão como`Unlisted`. ``` aws codeartifact list-package-versions --domain my-domain --repository \ my-maven-repo --package pkg-1 --namespace com.mycompany.myapp --format maven { "versions": [ { "version": "1.0-20210728.194552-1", "revision": "GipMW+599JmwTcTLaXo9YvDsVQ2bcrrk/02rWJhoKUU=", "status": "Unlisted" }, { "version": "1.0-SNAPSHOT", "revision": "tWu8n3IX5HR82vzVZQAxlwcvvA4U/+S80edWNAkil24=", "status": "Published" } ], "defaultDisplayVersion": "1.0-SNAPSHOT", "format": "maven", "package": "pkg-1", "namespace": "com.mycompany.myapp" } ``` Nesse ponto, a versão de snapshot `1.0-SNAPSHOT` pode ser consumida em uma compilação. Embora existam duas versões do `com.mycompany.myapp:pkg-1` no repositório `my-maven-repo`, ambas contêm os mesmos ativos. ``` aws codeartifact list-package-version-assets --domain my-domain --repository \ my-maven-repo --format maven --namespace com.mycompany.myapp \ --package pkg-1 --package-version 1.0-SNAPSHOT--query 'assets[*].name' [ "pkg-1-1.0-20210728.194552-1.jar", "pkg-1-1.0-20210728.194552-1.pom" ] ``` Executar o mesmo comando `list-package-version-assets` mostrado anteriormente com o parâmetro `--package-version` alterado para `1.0-20210728.194552-1` resulta em uma saída idêntica. À medida que outras compilações do `1.0-SNAPSHOT` são adicionadas ao repositório, uma nova versão `Unlisted` do pacote é criada para cada nova compilação. Os ativos da versão `1.0-SNAPSHOT` são atualizados todas as vezes, para que a versão sempre se refira à compilação mais recente. A atualização do `1.0-SNAPSHOT` com os ativos mais recentes é iniciada com o upload do arquivo `maven-metadata.xml` para a nova compilação. ## Consumir versões de snapshot Se você solicitar um snapshot, a versão com o status `Published` será retornada. É sempre a versão mais recente de snapshot do Maven. Você também pode solicitar uma compilação específica de um snapshot usando o número da versão da compilação (por exemplo, `1.0-20210728.194552-1`) em vez da versão de snapshot (por exemplo, `1.0-SNAPSHOT`) no caminho do URL. Para ver as versões de compilação de um snapshot do Maven, use a [ListPackageVersions ](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersions.html)API no *Guia da CodeArtifact API* e defina o parâmetro de status como. `Unlisted` ## Excluir versões de snapshot Para excluir todas as versões de compilação de um snapshot do Maven, use a [DeletePackageVersions](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_DeletePackageVersions.html)API, especificando as versões que você deseja excluir. ## Publicação de snapshot com curl Se você tiver versões de snapshots existentes armazenadas no Amazon Simple Storage Service (Amazon S3) ou em outro produto de repositório de artefatos, talvez queira republicá-las no. AWS CodeArtifact Devido à forma como CodeArtifact suporta instantâneos do Maven (consulte[Publicação de instantâneos em CodeArtifact](#maven-snapshot-publishing)), publicar instantâneos com um cliente HTTP genérico, como o, `curl` é mais complexo do que publicar versões de lançamento do Maven, conforme descrito em. [Publicar com curl](maven-curl.md) Observe que esta seção não será relevante se você estiver criando e implantando versões de snapshot com um cliente Maven como `mvn` ou `gradle`. É preciso seguir a documentação desse cliente. Publicar uma versão de snapshot envolve a publicação de uma ou mais compilações. Em CodeArtifact, se houver *n* compilações de uma versão de instantâneo, haverá *n \$1 1 CodeArtifact versões: *n** versões de compilação, todas com um status de`Unlisted`, e uma versão de instantâneo (a última compilação publicada) com um status de. `Published` A versão de snapshot (ou seja, a versão com uma string de versão que contém “-SNAPSHOT”) contém um conjunto de ativos idêntico ao da compilação mais recente publicada. A forma mais fácil de criar essa estrutura usando `curl` é a seguinte: 1. Publique todos os ativos de todas as compilações usando `curl`. 1. Publique o arquivo `maven-metadata.xml` da compilação mais recente (ou seja, a compilação com a marca de data e hora mais recente) com `curl`. Isso criará uma versão com “`-SNAPSHOT`” na string da versão e com o conjunto correto de ativos. 1. Use a [UpdatePackageVersionsStatus](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html)API para definir o status de todas as versões de compilação não mais recentes como`Unlisted`. Use os comandos `curl` a seguir para publicar ativos de snapshots (como arquivos. jar e .pom) para a versão `1.0-SNAPSHOT` de snapshot de um pacote `com.mycompany.app:pkg-1`: ``` curl --user "aws:$CODEARTIFACT_AUTH_TOKEN" -H "Content-Type: application/octet-stream" \ -X PUT https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_maven_repo/com/mycompany/app/pkg-1/1.0-SNAPSHOT/pkg-1-1.0-20210729.171330-2.jar \ --data-binary @pkg-1-1.0-20210728.194552-1.jar ``` ``` curl --user "aws:$CODEARTIFACT_AUTH_TOKEN" -H "Content-Type: application/octet-stream" \ -X PUT https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_maven_repo/com/mycompany/app/pkg-1/1.0-SNAPSHOT/pkg-1-1.0-20210729.171330-2.pom \ --data-binary @pkg-1-1.0-20210728.194552-1.pom ``` Ao usar esses exemplos: + *my\$1domain*Substitua pelo seu nome de CodeArtifact domínio. + *111122223333*Substitua pelo Conta da AWS ID do proprietário do seu CodeArtifact domínio. + *us-west-2*Substitua pelo Região da AWS em que seu CodeArtifact domínio está localizado. + *my\$1maven\$1repo*Substitua pelo nome CodeArtifact do seu repositório. **Importante** Será preciso prefixar o valor do parâmetro `--data-binary` com o caractere `@`. Ao colocar o valor entre aspas, `@` deve ser incluído entre aspas. Você pode ter mais de dois ativos para carregar em cada compilação. Por exemplo, pode haver arquivos Javadoc e JAR de origem, além do JAR principal e `pom.xml`. Não é necessário publicar arquivos de soma de verificação para os ativos da versão do pacote porque gera CodeArtifact automaticamente somas de verificação para cada ativo carregado. Para verificar se os ativos foram carregados corretamente, busque as somas de verificação geradas usando o comando `list-package-version-assets` e compare-as com as originais. Para obter mais informações sobre como CodeArtifact manipula as somas de verificação do Maven, consulte. [Usar somas de verificação do Maven](maven-checksums.md) Use o comando curl a seguir para publicar o arquivo `maven-metadata.xml` para a versão de compilação mais recente: ``` curl --user "aws:$CODEARTIFACT_AUTH_TOKEN" -H "Content-Type: application/octet-stream" \ -X PUT https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_maven_repo/com/mycompany/app/pkg-1/1.0-SNAPSHOT/maven-metadata.xml \ --data-binary @maven-metadata.xml ``` O arquivo `maven-metadata.xml` deve fazer referência a pelo menos um dos ativos na versão de compilação mais recente do elemento ``. Além disso, o valor `` deve estar presente e corresponder ao timestamp nos nomes dos arquivos do ativo. Por exemplo, para a compilação de `20210729.171330-2` publicada anteriormente, o conteúdo de `maven-metadata.xml` deve ser: ``` com.mycompany.app pkg-1 1.0-SNAPSHOT 20210729.171330 2 20210729171330 jar 1.0-20210729.171330-2 20210729171330 pom 1.0-20210729.171330-2 20210729171330 ``` Depois da publicação de `maven-metadata.xml`, a última etapa é definir que todas as outras versões de compilação (ou seja, todas as versões de compilação, exceto a compilação mais recente) tenham o status de versão do pacote de `Unlisted`. Por exemplo, se a versão `1.0-SNAPSHOT` tiver duas compilações, sendo a primeira compilação `20210728.194552-1`, o comando para definir essa compilação como `Unlisted` será: ``` aws codeartifact update-package-versions-status --domain my-domain --domain-owner 111122223333 \ --repository my-maven-repo --format maven --namespace com.mycompany.app --package pkg-1 \ --versions 1.0-20210728.194552-1 --target-status Unlisted ``` ## Snapshots e conexões externas Os instantâneos do Maven não podem ser obtidos de um repositório público do Maven por meio de uma conexão externa. AWS CodeArtifact só suporta a importação de versões de lançamento do Maven. ## Snapshots e repositórios upstream Em geral, os snapshots do Maven funcionam da mesma forma que as versões de lançamento do Maven, quando usadas com repositórios upstream. Porém, há uma limitação se você planeja publicar snapshots da mesma versão do pacote em dois repositórios que tenham uma relação upstream. Por exemplo, digamos que há dois repositórios em um AWS CodeArtifact domínio `R` e`U`, onde `U` está um upstream de. `R` Se você publicar uma nova compilação`R`, quando um cliente Maven solicitar a compilação mais recente dessa versão de snapshot, CodeArtifact retornará a versão mais recente de. `U` Isso pode ser inesperado, já que a versão mais recente agora é `R`, não `U`. Há duas maneiras de evitar isso: 1. Não publique compilações de uma versão de snapshot, como `1.0-SNAPSHOT` em `R`, se `1.0-SNAPSHOT` existir em `U`. 1. Use os controles de origem CodeArtifact do pacote para desativar os upstreams desse pacote em. `R` Isso permitirá que você publique compilações do `1.0-SNAPSHOT` em `R`, mas também impedirá que `R` obtenha outras versões desse pacote de `U` que ainda não tenham sido retidas. # Solicitação de pacotes Maven de upstreams e conexões externas ## Importação de nomes de ativos padrão Ao importar uma versão do pacote Maven de um repositório público, como o Maven Central, a AWS CodeArtifact tenta importar todos os ativos dessa versão do pacote. Conforme descrito em [Solicitar uma versão do pacote com repositórios upstream](repo-upstream-behavior.md), a importação ocorre quando: + Um cliente solicita um ativo Maven de um CodeArtifact repositório. + A versão do pacote ainda não está presente em seu repositório ou em upstreams. + Há uma conexão externa acessível com um repositório público do Maven. Mesmo que o cliente tenha solicitado apenas um ativo, CodeArtifact tenta importar todos os ativos encontrados para essa versão do pacote. A forma como CodeArtifact descobrir quais ativos estão disponíveis para uma versão do pacote Maven depende do repositório público específico. Alguns repositórios públicos do Maven oferecem suporte à solicitação de uma lista de ativos, mas outros não. Para repositórios que não fornecem uma forma de listar ativos, CodeArtifact gera um conjunto de nomes de ativos que provavelmente existem. Por exemplo, quando qualquer ativo da versão do pacote Maven `junit 4.13.2` for solicitado, CodeArtifact tentará importar os seguintes ativos: + `junit-4.13.2.pom` + `junit-4.13.2.jar` + `junit-4.13.2-javadoc.jar` + `junit-4.13.2-sources.jar` ## Importação de nomes de ativos não padrão Quando um cliente Maven solicita um ativo que não corresponde a um dos padrões descritos acima, CodeArtifact verifica se esse ativo está presente no repositório público. Se o ativo estiver presente, ele será importado e adicionado ao registro da versão do pacote existente, se houver. Por exemplo, a versão `com.android.tools.build:aapt2 7.3.1-8691043` do pacote Maver contém os seguintes ativos: + `aapt2-7.3.1-8691043.pom` + `aapt2-7.3.1-8691043-windows.jar` + `aapt2-7.3.1-8691043-osx.jar` + `aapt2-7.3.1-8691043-linux.jar` Quando um cliente solicita o arquivo POM, CodeArtifact se não conseguir listar os ativos da versão do pacote, o POM será o único ativo importado. Isso ocorre porque nenhum dos outros ativos corresponde aos padrões de nomes de ativos padrão. No entanto, quando o cliente solicita um dos ativos JAR, esse ativo será importado e adicionado à versão do pacote existente armazenada em CodeArtifact. As versões do pacote no repositório mais downstream (o repositório no qual o cliente fez a solicitação) e no repositório com a conexão externa anexada serão atualizadas para conter o novo ativo, conforme descrito em [Retenção de pacotes de repositórios upstream](repo-upstream-behavior.md#package-retention-upstream-repos). Normalmente, quando uma versão do pacote é retida em um CodeArtifact repositório, ela não é afetada pelas alterações nos repositórios upstream. Para obter mais informações, consulte [Retenção de pacotes de repositórios upstream](repo-upstream-behavior.md#package-retention-upstream-repos). No entanto, o comportamento dos ativos do Maven com nomes não padrão descritos anteriormente é uma exceção a essa regra. Embora a versão downstream do pacote não mude sem que um ativo adicional seja solicitado por um cliente, nessa situação, a versão retida do pacote é modificada após ser inicialmente retida e, portanto, não é imutável. Esse comportamento é necessário porque ativos do Maven com nomes não padrão, de outra forma, não estariam acessíveis por meio do. CodeArtifact O comportamento também é ativado se eles forem adicionados a uma versão do pacote Maven em um repositório público após a versão do pacote ter sido retida em um repositório. CodeArtifact ## Verificação das origens dos ativos Ao adicionar um novo ativo a uma versão de pacote Maven retida anteriormente, CodeArtifact confirma que a origem da versão retida do pacote é a mesma origem do novo ativo. Isso impede a criação de uma versão de pacote “mista” em que diferentes ativos são originários de diferentes repositórios públicos. Sem essa verificação, a mistura de ativos pode ocorrer se uma versão do pacote Maven for publicada em mais de um repositório público e esses repositórios fizerem parte do gráfico upstream de um CodeArtifact repositório. ## Importação de novos ativos e status da versão do pacote em repositórios upstream O [status da versão](packages-overview.md#package-version-status) do pacote das versões do pacote nos repositórios upstream pode CodeArtifact impedir a retenção dessas versões nos repositórios downstream. Por exemplo, digamos que um domínio tenha três repositórios:`repo-A`, `repo-B` e `repo-C`, onde `repo-B` é um upstream de `repo-A` e `repo-C` é upstream de `repo-B`. ![\[Um diagrama de como os novos ativos e versões de pacotes funcionam nos repositórios upstream.\]](http://docs.aws.amazon.com/pt_br/codeartifact/latest/ug/images/Maven-new-asset-pv-upstream.png) A versão `7.3.1` do pacote Maven `com.android.tools.build:aapt2` está presente em `repo-B` e tem o status de `Published`. Não está presente em `repo-A`. Se um cliente solicitar um ativo dessa versão do pacote do `repo-A`, a resposta será 200 (OK) e a versão `7.3.1` do pacote Maven será retida no `repo-A`. No entanto, se o status da versão `7.3.1` do pacote no `repo-B` for `Archived` ou`Disposed`, a resposta será 404 (Não encontrado), pois os ativos das versões do pacote nesses dois status não podem ser baixados. Observe que definir o [controle de origem do pacote](package-origin-controls.md) como `upstream=BLOCK` para `com.android.tools.build:aapt2` no `repo-A`, `repo-B` e `repo-C` evitará que novos ativos sejam buscados para todas as versões desse pacote do `repo-A`, independentemente do status da versão do pacote. # Solução de problemas do Maven As informações a seguir podem ajudar a solucionar problemas comuns com o Maven e o CodeArtifact. ## Desative as opções paralelas para corrigir o erro 429: Excesso de solicitações A partir da versão 3.9.0, o Maven carrega artefatos de pacotes em paralelo (até 5 arquivos por vez). Isso pode fazer com que o CodeArtifact responda ocasionalmente com um código de resposta de erro 429 (Excesso de solicitações). Se você se deparar com esse erro, pode desabilitar as opções paralelas para corrigi-lo. Para desativar as opções paralelas, defina a `aether.connector.basic.parallelPut` propriedade como `false` em seu perfil em seu arquivo `settings.xml`, conforme mostrado no exemplo a seguir: ``` default false ``` Para obter mais informações, consulte [Opções de configuração do resolvedor de artefatos](https://maven.apache.org/resolver/configuration.html) na documentação do Maven.