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

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? no site do Apache Maven Project.

O AWS CodeArtifact oferece suporte à publicação e consumo de snapshots do Maven. Snapshots exclusivos que usam um número de versão baseado em tempo são os únicos compatíveis. O CodeArtifact não é compatível com snapshots não exclusivos gerados por clientes do Maven 2. Você pode publicar um snapshot compatível do Maven em qualquer repositório do CodeArtifact.

Publicação de snapshots no CodeArtifact

O AWS CodeArtifact é compatível comos padrões de solicitação que os clientes, como mvn, usam ao publicar snapshots. 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 descreverá em detalhes como o CodeArtifact lida com snapshots.

Quando um snapshot do Maven é publicado em um repositório do CodeArtifact, a versão anterior dele é preservada em uma nova versão chamada de 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, as versões de snapshot de um pacote Maven chamado com.mycompany.myapp:pkg-1 são carregadas para um repositório do CodeArtifact 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, o CodeArtifact cria a versão 1.0-SNAPSHOT do pacote e define 1.0-20210728.194552-1 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 API ListPackageVersions no Guia de API do CodeArtifact e defina o parâmetro do status como Unlisted.

Excluir versões de snapshot

Para excluir todas as versões de compilação de um snapshot do Maven, use a API DeletePackageVersions, especificando as versões que você deseja excluir.

Publicação de snapshot com curl

Se você tiver versões existentes de snapshot armazenadas no Amazon Simple Storage Service (Amazon S3) ou em outro produto de repositório de artefatos, é possível que você queira republicá-las no AWS CodeArtifact. Devido à forma como o CodeArtifact é compatível com snapshots do Maven (consulte Publicação de snapshots no CodeArtifact), publicar snapshots 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. 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. No CodeArtifact, se houver n compilações de uma versão de snapshot, haverá n + 1 versões do CodeArtifact: n versões de compilação, todas com status de Unlisted, e uma versão de snapshot (a compilação mais recente publicada) com o 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:

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:

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 o CodeArtifact gera 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 o CodeArtifact trata as somas de verificação do Maven, consulte Usar somas de verificação do Maven.

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 <snapshotVersions>. Além disso, o valor <timestamp> 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:

<?xml version="1.0" encoding="UTF-8"?>
<metadata>
  <groupId>com.mycompany.app</groupId>
  <artifactId>pkg-1</artifactId>
  <version>1.0-SNAPSHOT</version>
  <versioning>
    <snapshot>
      <timestamp>20210729.171330</timestamp>
      <buildNumber>2</buildNumber>
    </snapshot>
    <lastUpdated>20210729171330</lastUpdated>
    <snapshotVersions>
      <snapshotVersion>
        <extension>jar</extension>
        <value>1.0-20210729.171330-2</value>
        <updated>20210729171330</updated>
      </snapshotVersion>
      <snapshotVersion>
        <extension>pom</extension>
        <value>1.0-20210729.171330-2</value>
        <updated>20210729171330</updated>
      </snapshotVersion>
    </snapshotVersions>
  </versioning>
</metadata>

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 snapshots do Maven não podem ser obtidos de um repositório público do Maven por meio de uma conexão externa. AWS O CodeArtifact só oferece suporte à 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, mas 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 haja dois repositórios em um domínio do AWS CodeArtifact, R e U, onde U é um upstream de R. Se você publicar uma nova compilação em R, quando um cliente Maven solicitar a compilação mais recente dessa versão de snapshot, o 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: