翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# MavenでCodeArtifactを使う
Mavenリポジトリ形式は Java、Kotlin、Scala、Clojureなど、さまざまな言語で使用されています。Maven、Gradle、Scala SBT、Apache Ivy、Leiningenなど、さまざまなビルドツールでサポートされています。
以下のバージョンで CodeArtifact との互換性をテストし、確認しました。
+ 最新の **Maven** バージョン: 3.6.3。
+ 最新の **Gradle** バージョン: 6.4.1、 5.5.1 もテスト済み。
+ 最新の **Clojure** バージョン: 1.11.1 もテスト済み。
**Topics**
+ [Gradle で CodeArtifact を使用する](maven-gradle.md)
+ [mvn で CodeArtifact を使用する](maven-mvn.md)
+ [CodeArtifact で deps.edn を使用する](maven-deps.md)
+ [curl で公開する](maven-curl.md)
+ [Maven チェックサムの使用](maven-checksums.md)
+ [Maven スナップショットを使用する](maven-snapshots.md)
+ [アップストリームと外部接続からの Maven パッケージのリクエスト](maven-upstream-external-connections-request.md)
+ [Maven のトラブルシューティング](maven-troubleshooting.md)
# Gradle で CodeArtifact を使用する
環境変数に CodeArtifact 認証トークンを取得した後、[環境変数を使用して認証トークンを渡す](tokens-authentication.md#env-var) の指示に従って、CodeArtifact リポジトリから Maven パッケージを使用し、新しいパッケージを CodeArtifact リポジトリに公開します。
**Topics**
+ [依存関係の取得](#fetching-dependencies)
+ [プラグインの取得](#fetching-plugins)
+ [アーティファクトの公開](#publishing-artifacts)
+ [IntelliJ IDEAで Gradle ビルドを実行する](#gradle-intellij)
## 依存関係の取得
Gradle ビルドの CodeArtifact から依存関係を取得するには、次の手順に従います。
**Gradle ビルドの CodeArtifact から依存関係を取得するには**
1. まだ実行していない場合は、「[環境変数を使用して認証トークンを渡す](tokens-authentication.md#env-var)」の手順に従って CodeArtifact 認証トークンを作成して環境変数に保存します。
1. プロジェクトファイル `build.gradle` の `repositories` セクションに `maven` セクションを追加します。
```
maven {
url 'https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/'
credentials {
username "aws"
password System.env.CODEARTIFACT_AUTH_TOKEN
}
}
```
上記の例の `url` は、CodeArtifact リポジトリのエンドポイントです。Gradle は、エンドポイントを使用してリポジトリに接続します。サンプルでは、`my_domain` はドメインの名前、`111122223333` はドメインの所有者の ID 、そして `my_repo` はリポジトリの名前です。`get-repository-endpoint` AWS CLI コマンドを使用して、リポジトリのエンドポイントを取得できます。
例えば、*my\$1domain* という名前の ドメイン内の*repo* という名前のリポジトリでは、コマンドは次のとおりです。
```
aws codeartifact get-repository-endpoint --domain my_domain --domain-owner 111122223333 --repository my_repo --format maven
```
`get-repository-endpoint` コマンドはリポジトリエンドポイントを返します。
```
url 'https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/'
```
上記の例の `credentials` オブジェクトには、手順 1 で作成した CodeArtifact 認証トークンが含まれています。Gradle は このトークンを CodeArtifact の認証に使用します。
**注記**
デュアルスタックエンドポイントを使用するには、`codeartifact.region.on.aws` エンドポイントを使用してください。
1. (オプション) CodeArtifact リポジトリをプロジェクトの依存関係の唯一のソースとして使用するには、`build.gradle` から `repositories` 内の他のセクションを削除します。複数のリポジトリがある場合、Gradle はリストされている順序で各リポジトリの依存関係を検索します。
1. リポジトリを構成したら、プロジェクトの依存関係を標準の Gradle 構文で `dependencies` セクションに追加できます。
```
dependencies {
implementation 'com.google.guava:guava:27.1-jre'
implementation 'commons-cli:commons-cli:1.4'
testImplementation 'org.testng:testng:6.14.3'
}
```
## プラグインの取得
デフォルトでは、Gradle はパブリック [Gradle Plugin Portal](https://plugins.gradle.org/) からプラグインを解決します。CodeArtifact リポジトリからプラグインをプルするには、次の手順に従います。
**CodeArtifact リポジトリからプラグインをプルするには**
1. まだ実行していない場合は、「[環境変数を使用して認証トークンを渡す](tokens-authentication.md#env-var)」の手順に従って CodeArtifact 認証トークンを作成して環境変数に保存します。
1. `pluginManagement` ブロックを `settings.gradle` ファイルに追加します。`pluginManagement` ブロックは、`settings.gradle` の他のステートメントの前に置く必要があります。次のスニペットを参照してください。
```
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
}
}
}
}
```
これにより、Gradle は指定したリポジトリからプラグインを解決します。一般的に必要な Gradle プラグインをビルドで使用できるように、リポジトリには Gradle Plugin Portal への外部接続を持つ上流リポジトリが必要です (例: `gradle-plugins-store`) 。詳細については、[Gradle ドキュメント](https://docs.gradle.org/current/userguide/plugins.html#sec:custom_plugin_repositories) を参照してください。
## アーティファクトの公開
このセクションでは、Gradle でビルドされた Java ライブラリを CodeArtifact リポジトリに公開する方法について説明します。
まず、`maven-publish` プラグインをプロジェクトの `build.gradle` ファイルの `plugins` セクションに追加します。
```
plugins {
id 'java-library'
id 'maven-publish'
}
```
次に、`publishing` セクションをプロジェクト `build.gradle` ファイルに追加します。
```
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
}
}
}
}
```
`maven-publish` プラグインは、`publishing` セクションで指定された `groupId`、`artifactId` および `version` に基づいて POM ファイルを生成します。
これらの `build.gradle` への変更が完了したら、次のコマンドを実行してプロジェクトをビルドし、それをリポジトリにアップロードします。
```
./gradlew publish
```
`list-package-versions`を使用して、パッケージが正常に発行されたことを確認します。
```
aws codeartifact list-package-versions --domain my_domain --domain-owner 111122223333 --repository my_repo --format maven\
--namespace com.company.framework --package my-package-name
```
サンプル出力:
```
{
"format": "maven",
"namespace": "com.company.framework",
"package": "example",
"versions": [
{
"version": "1.0",
"revision": "REVISION-SAMPLE-1-C7F4S5E9B772FC",
"status": "Published"
}
]
}
```
詳細については、Gradle ウェブサイトで以下のトピックを参照してください。
+ [Java ライブラリの構築](https://guides.gradle.org/building-java-libraries/)
+ [プロジェクトをモジュールとして公開する](https://docs.gradle.org/current/userguide/publishing_setup.html)
## IntelliJ IDEAで Gradle ビルドを実行する
IntelliJ IDEAで、CodeArtifact から依存関係をプルする Gradle ビルドを実行できます。CodeArtifact で認証するには、CodeArtifact 認可トークンを Gradle に提供する必要があります。認証トークンを提供する方法は 3 つあります。
+ 方法 1: `gradle.properties` に認証トークンを保存する。この方法は、`gradle.properties` ファイルのコンテンツに上書きまたは追加できる場合に使用します。
+ 方法 2: 認証トークンを別のファイルに保存する。この方法は、`gradle.properties` ファイルを修正したくない場合に使用します。
+ 方法 3: `aws` を `build.gradle` のインラインスクリプトとして実行して、実行ごとに新しい認証トークンを生成する。この方法は、実行ごとに Gradle スクリプトが新しいトークンを取得するようにしたい場合に使用します。トークンはファイルシステムに保存されません。
------
#### [ Token stored in gradle.properties ]
**方法 1: `gradle.properties` に認証トークンを保存する。**
**注記**
この例は `GRADLE_USER_HOME` にある `gradle.properties` ファイルを示します。
1. 次のスニペットを使用して `build.gradle` ファイルを更新する:
```
repositories {
maven {
url 'https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/'
credentials {
username "aws"
password "$codeartifactToken"
}
}
}
```
1. CodeArtifact からプラグインをフェッチするには、`settings.gradle` ファイル に `pluginManagement` ブロックを追加します。`pluginManagement` ブロックは、`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. CodeArtifact 認証トークンを取得します。
```
export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token --domain my_domain --domain-owner 111122223333 --query authorizationToken --output text --profile profile-name`
```
1. `gradle.properties` ファイルに認証トークンを書き込む:
```
echo "codeartifactToken=$CODEARTIFACT_AUTH_TOKEN" > ~/.gradle/gradle.properties
```
------
#### [ Token stored in separate file ]
**方法 2: 認証トークンを別のファイルに保存する**
1. 次のスニペットを使用して `build.gradle` ファイルを更新する:
```
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. CodeArtifact からプラグインをフェッチするには、`settings.gradle` ファイル に `pluginManagement` ブロックを追加します。`pluginManagement` ブロックは、`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. CodeArtifact 認証トークンを取得します。
```
export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token --domain my_domain --domain-owner 111122223333 --query authorizationToken --output text --profile profile-name`
```
1. `build.gradle` ファイルで指定したファイルに認証トークンを書き込みます。
```
echo "codeartifactToken=$CODEARTIFACT_AUTH_TOKEN" > file
```
------
#### [ Token generated for each run in build.gradle ]
**方法 3: `aws` を `build.gradle` のインラインスクリプトとして実行して、実行ごとに新しい認証トークンを生成する。**
1. 次のスニペットを使用して `build.gradle` ファイルを更新する:
```
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. CodeArtifact からプラグインをフェッチするには、`settings.gradle` ファイル に `pluginManagement` ブロックを追加します。`pluginManagement` ブロックは、`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
}
}
}
}
```
------
# mvn で CodeArtifact を使用する
Maven ビルドを実行するには、`mvn` コマンドを使用してください。このセクションでは、CodeArtifact リポジトリを使用して `mvn` を設定する方法を示します。
**Topics**
+ [依存関係の取得](#fetching-dependencies)
+ [アーティファクトの公開](#publishing-artifacts)
+ [サードパーティのアーティファクト](#publishing-third-party-artifacts)
+ [CodeArtifact リポジトリへの Maven 依存関係のダウンロードを制限する](#restrict-maven-downloads)
+ [Apache Maven プロジェクト情報](#apache-maven-project-info)
## 依存関係の取得
`mvn`を設定して CodeArtifact リポジトリから依存関係を取得するには、Maven 設定ファイル `settings.xml`、オプションで、プロジェクトの POM を編集する必要があります。。
1. まだ行っていない場合は、CodeArtifact リポジトリへの認証を設定する「[環境変数を使用して認証トークンを渡す](tokens-authentication.md#env-var)」の説明に従って、CodeArtifact 認証トークンを作成して環境変数に保存します。
1. `settings.xml` (通常、`~/.m2/settings.xml`の場所にあります。) で、`CODEARTIFACT_AUTH_TOKEN` 環境変数を参照して `` セクションを追加し、HTTP リクエストで Maven が トークンを渡すようにします。
```
...
codeartifact
aws
${env.CODEARTIFACT_AUTH_TOKEN}
...
```
1. `` 要素にある CodeArtifact リポジトリの URL エンドポイントを追加します。これは、`settings.xml`またはプロジェクトの POM ファイルで行えます。
リポジトリのエンドポイントを取得するには、 `get-repository-endpoint` AWS CLI コマンドを使用します。
例えば、*my\$1domain* という名前のドメイン内の *repo* という名前のリポジトリのコマンドは次のとおりです。
```
aws codeartifact get-repository-endpoint --domain my_domain --repository my_repo --format maven
```
`get-repository-endpoint` コマンドはリポジトリエンドポイントを返します。
```
url 'https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/'
```
**注記**
デュアルスタックエンドポイントを使用するには、`codeartifact.region.on.aws` エンドポイントを使用してください。
`settings.xml` へのリポジトリエンドポイントの追加は以下のとおりです。
```
...
default
codeartifact
https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/
default
...
```
または、`` セクションをプロジェクトの POM ファイルに追加して、そのプロジェクトに対してのみ CodeArtifact を使用できます。
```
...
codeartifact
codeartifact
https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/
...
```
**重要**
`` 要素にある任意の値を使用できますが、`` および `` 要素の両方で同じでなければなりません。これにより、指定された認証情報を CodeArtifact へのリクエストに含めることができます。
これらの設定変更を行った後、プロジェクトを構築できます。
```
mvn compile
```
Maven は、ダウンロードするすべての依存関係の完全な URL をコンソールに記録します。
```
[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)
```
## アーティファクトの公開
`mvn` で Maven アーティファクトを CodeArtifact リポジトリに公開するには、`~/.m2/settings.xml` およびプロジェクト POM を編集する必要もあります。
1. まだ行っていない場合は、CodeArtifact リポジトリへの認証を設定する「[環境変数を使用して認証トークンを渡す](tokens-authentication.md#env-var)」の説明に従って、CodeArtifact 認証トークンを作成して環境変数に保存します。
1. `CODEARTIFACT_AUTH_TOKEN` 環境変数を参照して `` セクションを `settings.xml` に追加し、Maven が HTTP リクエストで トークンを渡すようにします。
```
...
codeartifact
aws
${env.CODEARTIFACT_AUTH_TOKEN}
...
```
1. `` セクションをプロジェクトの `pom.xml` に追加します。
```
...
codeartifact
codeartifact
https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/
...
```
これらの設定変更を行った後、プロジェクトを構築して指定したリポジトリに公開できます。
```
mvn deploy
```
`list-package-versions` を使用して、パッケージが正常に公開されたことを確認します。
```
aws codeartifact list-package-versions --domain my_domain --domain-owner 111122223333 --repository my_repo --format maven \
--namespace com.company.framework --package my-package-name
```
サンプル出力:
```
{
"defaultDisplayVersion": null,
"format": "maven",
"namespace": "com.company.framework",
"package": "my-package-name",
"versions": [
{
"version": "1.0",
"revision": "REVISION-SAMPLE-1-C7F4S5E9B772FC",
"status": "Published"
}
]
}
```
## サードパーティのアーティファクト
`mvn deploy:deploy-file` を使用して、サードパーティ Maven アーティファクトを CodeArtifact リポジトリに公開できます。これは、アーティファクトを公開し、JAR ファイルのみを持ち、パッケージソースコードや POM ファイルにアクセスできないユーザーに役立ちます。
`mvn deploy:deploy-file` コマンド は、コマンドラインで渡された情報に基づいて POM ファイルを生成します。
**サードパーティの Maven アーティファクトを公開する**
1. まだ行っていない場合は、CodeArtifact リポジトリへの認証を設定する「[環境変数を使用して認証トークンを渡す](tokens-authentication.md#env-var)」の説明に従って、CodeArtifact 認証トークンを作成して環境変数に保存します。
1. 次のコンテンツを含む `~/.m2/settings.xml` ファイルを作成します。
```
codeartifact
aws
${env.CODEARTIFACT_AUTH_TOKEN}
```
1. `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/
```
**注記**
上記の例は `commons-cli 1.4` を公開しています。groupId、artifactID、version、およびファイルの引数を変更して、別の JAR を公開します。
この手順は、*Apache Maven ドキュメント* の [サードパーティの JAR をリモートリポジトリにデプロイするためのガイド](https://maven.apache.org/guides/mini/guide-3rd-party-jars-remote.html) の例に基づいています。
## CodeArtifact リポジトリへの Maven 依存関係のダウンロードを制限する
設定されたリポジトリからパッケージを取得できない場合、デフォルトで`mvn`コマンドでMaven Centralからパッケージを取得します。`mirrors`要素を`settings.xml`に追加して、`mvn`が常に CodeArtifact リポジトリを使用するようにします。
```
...
central-mirror
CodeArtifact Maven Central mirror
https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/
central
...
```
`mirrors`要素を追加すると、`settings.xml`または`pom.xml`に`pluginRepository`要素が含まれる必要があります。次の例では、CodeArtifact リポジトリからアプリケーションの依存関係と Maven プラグインを取得します。
```
...
codeartifact
CodeArtifact Plugins
https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/
true
true
...
```
次の例では、CodeArtifact リポジトリからアプリケーションの依存関係を取得し、Maven CentralからMaven プラグインを取得します。
```
default
...
central-plugins
Central Plugins
https://repo.maven.apache.org/maven2/
true
true
....
```
## Apache Maven プロジェクト情報
Maven の詳細については、Apache Maven プロジェクトウェブサイトの以下のトピックを参照してください。
+ [複数のリポジトリの設定](https://maven.apache.org/guides/mini/guide-multiple-repositories.html)
+ [設定リファレンス](https://maven.apache.org/settings.html)
+ [ディストリビューション管理](https://maven.apache.org/pom.html#Distribution_Management)
+ [プロファイル](https://maven.apache.org/pom.html#Profiles)
# CodeArtifact で deps.edn を使用する
`deps.edn` と `clj` を使用して、Clojure プロジェクトの依存関係を管理します。このセクションでは、CodeArtifact リポジトリを使用して `deps.edn` を設定する方法を示します。
**Topics**
+ [依存関係の取得](#fetching-dependencies-deps)
+ [アーティファクトの公開](#publishing-artifacts-deps)
## 依存関係の取得
`Clojure` を設定して CodeArtifact リポジトリから依存関係を取得するには、Maven 設定ファイル `settings.xml` を編集する必要があります。
1. `CODEARTIFACT_AUTH_TOKEN` 環境変数を参照して `` セクションを `settings.xml` に追加し、Clojure が HTTP リクエストでトークンを渡すようにします。
**注記**
Clojure は settings.xml ファイルが `~/.m2/settings.xml` にあることを想定しています。他の場所にある場合は、この場所にファイルを作成してください。
```
...
codeartifact
aws
${env.CODEARTIFACT_AUTH_TOKEN}
...
```
1. ファイルを作成していない場合は、`clj -Spom` を使用してプロジェクト用の POM xml を生成します。
1. `deps.edn` 設定ファイルに、Maven `settings.xml` のサーバー ID と一致するリポジトリを追加します。
```
:mvn/repos {
"clojars" nil
"central" nil
"codeartifact" {:url "https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/"}
}
```
**注記**
`clojars` によって、Maven ライブラリーの `tools.deps` と `central` リポジトリが最初にチェックされることが保証されます。その後、`deps.edn` に記載されている他のリポジトリがチェックされます。
Clojars と Maven Central から直接ダウンロードされないようにするには、`central` と `clojars` を `nil` に設定する必要があります。
CodeArtifact Auth トークンが環境変数に含まれていることを確認してください (「[環境変数を使用して認証トークンを渡す](tokens-authentication.md#env-var)」を参照)。これらの変更後にパッケージを構築する際、`deps.edn` の依存関係が CodeArtifact から取得されます。
**注記**
デュアルスタックエンドポイントを使用するには、`codeartifact.region.on.aws` エンドポイントを使用してください。
## アーティファクトの公開
1. Maven 設定 と `deps.edn` を更新して、CodeArtifact を Maven で認識されるサーバーとして含めるようにします (「[依存関係の取得](#fetching-dependencies-deps)」を参照)。[deps-deploy](https://github.com/slipset/deps-deploy) などのツールを使用して、アーティファクトを CodeArtifact にアップロードできます。
1. `build.clj` に、以前に設定した `codeartifact` リポジトリに必要なアーティファクトをアップロードする `deploy` タスクを追加します。
```
(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. `clj -T:build deploy` コマンドを実行してアーティファクトを公開します。
デフォルトリポジトリの変更に関する詳細は、「*Clojure Deps and CLI Reference Rationale*」の「[Modifying the default repositories](https://clojure.org/reference/deps_and_cli#_modifying_the_default_repositories)」を参照してください。
# curl で公開する
このセクションでは、HTTP クライアント `curl` を使用して、Maven Artifact (アーティファクト) を CodeArtifact リポジトリに公開する方法を説明します。`curl` を使用したArtifact (アーティファクト) の公開は、Maven クライアントを環境にインストールしていない、またはインストールしたくない場合に便利です。
**`curl` を使用して Maven Artifact (アーティファクト) を公開する**
1. CodeArtifact 認可トークンを取得するには、「[環境変数を使用して認証トークンを渡す](tokens-authentication.md#env-var)」のステップに従います。その後、これらのステップに戻ります。
1. 次の `curl` コマンドを使用して、JAR を CodeArtifact リポジトリに公開します。
この手順の各 `curl` コマンドで、次のプレースホルダを置き換えます。
+ *my\$1domain* を CodeArtifact ドメイン名に置き換えます。
+ *111122223333* を CodeArtifact ドメインの所有者の ID に置き換えます。
+ *us-west-2* を CodeArtifact ドメインがあるリージョンに置き換えます。
+ *my\$1repo* を 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
```
**重要**
`--data-binary` パラメータの値には `@` 文字をプレフィックスとして付ける必要があります。値を引用符で囲む場合は、`@` を引用符で囲む必要があります。
1. 次の `curl` コマンドを使用して、POM を 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. この時点で、Maven Artifact (アーティファクト) は `Unfinished` のステータスで CodeArtifact リポジトリにあります。パッケージを消費できるようにするには、パッケージが `Published` のステータスである必要があります。パッケージを `Unfinished` から `Published` に移動するには、`maven-metadata.xml` ファイルをパッケージにアップロードするか、[[UpdatePackageVersionsStatus API]](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html) を呼び出して、ステータスを変更します。
1. オプション 1: 次の `curl` コマンドを使用して、`maven-metadata.xml` ファイルをパッケージに追加する:
```
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
```
次に示すのは、`maven-metadata.xml` ファイルのコンテンツの例です:
```
com.mycompany.app
my-app
1.0
1.0
1.0
20200731090423
```
1. オプション 2: `UpdatePackageVersionsStatus` API を使用して、パッケージのステータスを `Published` に更新する。
```
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
```
Artifact (アーティファクト) の JAR ファイルしかない場合は、`mvn` を使用して使用可能なパッケージ版を CodeArtifact リポジトリに公開できます。これは、Artifact (アーティファクト) のソースコードまたは POM にアクセスできない場合に便利です。詳細については、「[サードパーティのアーティファクト](maven-mvn.md#publishing-third-party-artifacts)」を参照してください。
# Maven チェックサムの使用
Maven アーティファクトが AWS CodeArtifact リポジトリに発行されると、パッケージ内の各*アセット*またはファイルに関連付けられたチェックサムを使用してアップロードを検証します。アセットの例は、*[jar]*、*[pom]* および *[war]* ファイルです。各アセットについて、Maven Artifact (アーティファクト) には、`md5` または `sha1` など、アセット名に追加の拡張子が付いた複数のチェックサムファイルが含まれています。例えば、`my-maven-package.jar` という名前のファイルのチェックサムファイルは `my-maven-package.jar.md5` および `my-maven-package.jar.sha1` である可能性があります。
**注記**
Maven はこの条件 `artifact` を使用します。このガイドでは、Maven パッケージは Maven Artifact (アーティファクト) と同じです。詳細については、[[AWS CodeArtifact パッケージ]](https://docs.aws.amazon.com/codeartifact/latest/ug/welcome.html#welcome-concepts-package) を参照してください。
## チェックサムストレージ
CodeArtifact は Maven チェックサムをアセットとして保存しません。つまり、[ListPackageVersionAssets API](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersionAssets.html) の出力では、チェックサムは個別のアセットとして表示されません。代わりに、CodeArtifact によって計算されたチェックサムは、サポートされているすべてのチェックサムタイプの各アセットで使用できます。例えば、Maven のパッケージバージョン `commons-lang:commons-lang 2.1` で ListPackageVersionAssets を呼び出す場合の応答の一部は次のようになります。
```
{
"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"
}
}
```
チェックサムはアセットとして保存されませんが、Maven クライアントは期待される場所でチェックサムを公開およびダウンロードできます。例えば、`commons-lang:commons-lang 2.1` が `maven-repo` というリポジトリにある場合、JAR ファイルの SHA-256 チェックサムの URL パスは次のようになります。
```
/maven/maven-repo/commons-lang/commons-lang/2.1/commons-lang-2.1.jar.sha256
```
既存の Maven パッケージ (以前に Amazon S3 に保存されたパッケージなど) を、`curl` などの汎用 HTTP クライアントを使用して CodeArtifact にアップロードする場合、チェックサムをアップロードする必要はありません。CodeArtifact はそれらを自動的に生成します。アセットが正しくアップロードされたことを確認するには、ListPackageVersionAssets API オペレーションを使用して、レスポンス内のチェックサムを各アセットの元のチェックサム値と比較します。
## 公開中のチェックサムの不一致
アセットとチェックサムの他に、Maven アーティファクトには `maven-metadata.xml` ファイルも含まれています。Maven パッケージの通常の公開手順では、すべてのアセットとチェックサムを最初にアップロードし、その後に `maven-metadata.xml` をアップロードします。例えば、前述の Maven パッケージバージョン `commons-lang 2.1` の公開順序は、クライアントが SHA-256 チェックサムファイルを公開するように設定されていると仮定すると、次のようになります。
```
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
```
JAR ファイルなどのアセットのチェックサムファイルをアップロードする際に、アップロードされたチェックサム値と CodeArtifact によって計算されたチェックサム値の間に不一致があると、チェックサムのアップロードリクエストは **400 (Bad Request)** レスポンスで失敗します。対応するアセットが存在しない場合、リクエストは **404 (Not Found)** レスポンスで失敗します。このエラーを回避するには、まずアセットをアップロードし、次にチェックサムをアップロードする必要があります。
`maven-metadata.xml` をアップロードする際、CodeArtifact は通常 Maven パッケージバージョンのステータスを `Unfinished` から `Published` に変更します。いずれかのアセットでチェックサムの不一致が検出された場合、CodeArtifact は `maven-metadata.xml` 公開リクエストへの応答で **400 (Bad Request)** を返します。このエラーにより、クライアントはこのパッケージバージョンのファイルのアップロードを停止することがあります。アップロードが停止し、`maven-metadata.xml` ファイルがアップロードされない場合、アップロード済みのパッケージバージョンのアセットはダウンロードできません。これは、パッケージバージョンのステータスが `Published` に設定されておらず、`Unfinished` のままであるためです。
CodeArtifact では、`maven-metadata.xml` がアップロードされパッケージバージョンのステータスが `Published` に設定された後でも、Maven のパッケージバージョンにさらにアセットを追加できます。このステータスでは、一致しないチェックサムファイルをアップロードするリクエストも **400 (Bad Request)** レスポンスで失敗します。ただし、パッケージバージョンのステータスはすでに `Published` に設定されているため、チェックサムファイルのアップロードに失敗したものも含め、パッケージから任意のアセットをダウンロードできます。チェックサムファイルのアップロードに失敗したアセットのチェックサムをダウンロードする場合、クライアントが受け取るチェックサム値は、アップロードされたアセットデータに基づいて CodeArtifact によって計算されたチェックサム値になります。
CodeArtifact のチェックサム比較では大文字と小文字が区別され、CodeArtifact によって計算されたチェックサムは小文字でフォーマットされます。そのため、チェックサム `909FA780F76DA393E992A3D2D495F468` をアップロードすると、CodeArtifact では `909fa780f76da393e992a3d2d495f468` と同じチェックサムとして扱われないため、チェックサムの不一致でアップロードが失敗します。
## チェックサムの不一致の解決
チェックサムの不一致が原因でチェックサムのアップロードが失敗した場合は、次のいずれかを試して問題を解決します。
+ Maven アーティファクトを公開するコマンドを再度実行します。これは、ダウンロード中にネットワークの問題によってチェックサムファイルが破損した場合に役立つ可能性があります。再試行でネットワークの問題が解決された場合は、チェックサムが一致し、ダウンロードが成功します。
+ パッケージバージョンを削除して、再度公開します。詳細については、「*AWS CodeArtifact API Reference*」の「[DeletePackageVersions](https://docs.aws.amazon.com/dms/latest/APIReference/API_DeletePackageVersions.html)」を参照してください。
# Maven スナップショットを使用する
Maven *スナップショット* は、最新のプロダクションブランチコードを参照する Maven パッケージの特別なバージョンです。これは最終リリース版に先行する開発版です。Maven パッケージのスナップショットバージョンは、パッケージバージョンに追加されているサフィックス `SNAPSHOT` で識別できます。例えば、バージョン `1.1` のスナップショットは `1.1-SNAPSHOT` です。詳細については、Apache Maven プロジェクトウェブサイト上の [スナップショットバージョンとは何ですか？](https://maven.apache.org/guides/getting-started/index.html#What_is_a_SNAPSHOT_version) を参照してください。
AWS CodeArtifact は Maven スナップショットの発行と消費をサポートしています。サポートされているスナップショットは、時間ベースのバージョン番号を使用する一意のスナップショットのみです。CodeArtifact は、Maven 2 クライアントによって生成される一意でないスナップショットをサポートしていません。サポートされている Maven スナップショットは、任意の CodeArtifact リポジトリに公開できます。
**Topics**
+ [スナップショットを CodeArtifact で公開する](#maven-snapshot-publishing)
+ [スナップショットバージョンを使用する](#maven-consuming-snapshot-versions)
+ [スナップショットバージョンを削除する](#maven-deleting-snapshot-versions)
+ [curl を使用してスナップショットを公開する](#maven-snapshot-publishing-curl)
+ [スナップショットと外部接続](#maven-snapshot-external-connections)
+ [スナップショットとアップストリームリポジトリ](#maven-snapshot-upstream-repositories)
## スナップショットを CodeArtifact で公開する
AWS CodeArtifact は、 などのクライアントがスナップショットを発行するときに`mvn`使用するリクエストパターンをサポートしています。そのため、Maven スナップショットの公開方法を詳しく理解していなくても、ビルドツールやパッケージマネージャーのドキュメントに従って操作することができます。より複雑な操作を実行する場合は、このセクションの CodeArtifact のスナップショットの処理方法を参照してください。
Maven スナップショットが CodeArtifact に公開されると、その前のバージョンはビルドという新しいバージョンに保存されます。Maven スナップショットが公開されるたびに、新しいビルドバージョンが作成されます。スナップショットの以前のバージョンはすべて、ビルドバージョンで保持されます。Maven スナップショットが公開されると、そのパッケージバージョンのステータスは `Published` に設定され、前のバージョンを含むビルドのステータスは `Unlisted` に設定されます。この動作は、パッケージバージョンに `-SNAPSHOT` サフィックスが付いている Maven パッケージバージョンのみに適用されます。
例えば、`com.mycompany.myapp:pkg-1` という Maven パッケージのスナップショットバージョンは、`my-maven-repo` という CodeArtifact リポジトリにアップロードされます。スナップショットバージョンは `1.0-SNAPSHOT` です。この時点では、`com.mycompany.myapp:pkg-1` のバージョンは公開されていません。まず、初期ビルドのアセットが以下のパスで公開されます。
```
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
```
タイムスタンプ `20210728.194552-1` は、スナップショットビルドを公開するクライアントによって生成されることに注意してください。
.pom ファイルと.jar ファイルがアップロードされると、リポジトリに存在する唯一の `com.mycompany.myapp:pkg-1` のバージョンは `1.0-20210728.194552-1` です。これは、前のパスで指定されたバージョンが `1.0-SNAPSHOT` である場合でも同様です。この時点でのパッケージバージョンステータスは `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"
}
```
次に、クライアントはパッケージバージョンの `maven-metadata.xml` ファイルをアップロードします。
```
PUT my-maven-repo/com/mycompany/myapp/pkg-1/1.0-SNAPSHOT/maven-metadata.xml
```
maven-metadata.xml ファイルが正常にアップロードされると、CodeArtifact は `1.0-SNAPSHOT` パッケージバージョンを作成し、`1.0-20210728.194552-1` バージョンを `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"
}
```
この時点で、スナップショットバージョン `1.0-SNAPSHOT` はビルドで使用できます。リポジトリ `my-maven-repo` には `com.mycompany.myapp:pkg-1` の 2 つのバージョンが存在しますが、どちらも同じアセットを含んでいます。
```
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"
]
```
`--package-version` パラメータを `1.0-20210728.194552-1` に変更して上記と同じ `list-package-version-assets` コマンドを実行すると、同じ出力が得られます。
`1.0-SNAPSHOT` のビルドがリポジトリに追加されると、新しいビルドごとに新しい `Unlisted` パッケージバージョンが作成されます。バージョン `1.0-SNAPSHOT` のアセットは毎回更新されるため、バージョンは常にそのバージョンの最新ビルドになります。`1.0-SNAPSHOT` を最新のアセットで更新するには、新しいビルドの `maven-metadata.xml` ファイルをアップロードします。
## スナップショットバージョンを使用する
スナップショットをリクエストすると、ステータス `Published` を持つバージョンが返されます。これは常に Maven スナップショットの最新バージョンです。URL パス内のスナップショットバージョン (`1.0-SNAPSHOT` など) の代わりにビルドバージョン番号 (`1.0-20210728.194552-1` など) を使用して、スナップショットの特定のビルドをリクエストすることもできます。Maven スナップショットのビルドバージョンを確認するには、「*CodeArtifact API Guide*」の [ListPackageVersions ](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersions.html) API を使用して、ステータスパラメータを `Unlisted` に設定します。
## スナップショットバージョンを削除する
Maven スナップショットのすべてのビルドバージョンを削除するには、[DeletePackageVersions](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_DeletePackageVersions.html) API を使用して削除するバージョンを指定します。
## curl を使用してスナップショットを公開する
Amazon Simple Storage Service (Amazon S3) または別のアーティファクトリポジトリ製品に保存されている既存のスナップショットバージョンがある場合は、 AWS CodeArtifact に再公開できます。CodeArtifact は Maven スナップショットをサポートしているため (「[スナップショットを CodeArtifact で公開する](#maven-snapshot-publishing)」を参照)、`curl` などの汎用 HTTP クライアントを使用してスナップショットを公開することは、「[curl で公開する](maven-curl.md)」で説明されている Maven リリースバージョンの公開よりも複雑になります。`mvn` や `gradle` などの Maven クライアントでスナップショットバージョンをビルドしてデプロイする場合、このセクションの記載は適用されないことに注意してください。対象のクライアントのドキュメントに従ってください。
スナップショットバージョンを公開するには、スナップショットバージョンの 1 つ以上のビルドを公開する必要があります。CodeArtifact では、スナップショットバージョンのビルドが *n* 件ある場合、*n\$1 1* の CodeArtifact バージョンが存在します。*n* 個のすべてのビルドバージョンのステータスは `Unlisted` で、1 つのスナップショットバージョン（最新の公開ビルド）のステータスは `Published` です。スナップショットバージョン (つまり、「-SNAPSHOT」を含むバージョン文字列を含むバージョン) には、最新の公開ビルドと同じアセットセットが含まれています。`curl` を使用してこの構造を作成する最も簡単な方法は次のとおりです。
1. `curl` を使用して、すべてのビルドのすべてのアセットを公開します。
1. `curl` を使用して、前のビルド (最新の日付/タイムスタンプが付いたビルド) の `maven-metadata.xml` ファイルを公開します。これにより、バージョン文字列に「`-SNAPSHOT`」を含み、正しいアセットセットを含むバージョンが作成されます。
1. [UpdatePackageVersionsStatus](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html) API を使用して、最新でないすべてのビルドバージョンのステータスを `Unlisted` に設定します。
以下の `curl` コマンドを使用して、`com.mycompany.app:pkg-1` パッケージのスナップショットバージョン `1.0-SNAPSHOT` 用のスナップショットアセット (.jar ファイルや.pom ファイルなど) を公開します。
```
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
```
これらの例を使用する場合:
+ *my\$1domain* を CodeArtifact ドメイン名に置き換えます。
+ *111122223333* を CodeArtifact ドメインの所有者の AWS アカウント ID に置き換えます。
+ *us-west-2* を CodeArtifact ドメインがある AWS リージョン に置き換えます。
+ *my\$1maven\$1repo* を CodeArtifact リポジトリ名に置き換えます。
**重要**
`--data-binary` パラメータの値には `@` 文字をプレフィックスとして付ける必要があります。値を引用符で囲む場合は、`@` を引用符で囲む必要があります。
ビルドごとにアップロードするアセットが 3 つ以上ある場合があります。例えば、メインの JAR と `pom.xml` に加えて Javadoc ファイルとソース JAR ファイルがある場合があります。CodeArtifact はアップロードされたアセットごとにチェックサムを自動的に生成するため、パッケージバージョンアセットのチェックサムファイルを公開する必要はありません。アセットが正しくアップロードされたことを確認するには、`list-package-version-assets` コマンドを使用して生成されたチェックサムを取得し、元のチェックサムと比較します。CodeArtifact での Maven チェックサムの処理方法の詳細については、「[Maven チェックサムの使用](maven-checksums.md)」を参照してください。
次の curl コマンドを使用して、最新のビルドバージョンの `maven-metadata.xml` ファイルを公開します。
```
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
```
`maven-metadata.xml` ファイルは、`` エレメントの最新ビルドバージョンのアセットを少なくとも 1 つ参照している必要があります。また `` 値があり、アセットファイル名のタイムスタンプと一致している必要があります。例えば、以前に公開された `20210729.171330-2` ビルドの場合、`maven-metadata.xml` の内容は次のようになります。
```
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
```
`maven-metadata.xml` を公開した後の最後のステップは、他のすべてのビルドバージョン (最新のビルド以外のすべてのビルドバージョン) のパッケージバージョンステータスを `Unlisted` に設定することです。例えば、`1.0-SNAPSHOT` バージョンに 2 つのビルドがあり、最初のビルドが `20210728.194552-1` の場合、そのビルドを設定するコマンドは `Unlisted` になります。
```
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
```
## スナップショットと外部接続
Maven スナップショットは、外部接続を介して Maven パブリックリポジトリから取得することはできません。 AWS CodeArtifact は Maven リリースバージョンのインポートのみをサポートしています。
## スナップショットとアップストリームリポジトリ
一般的に、Maven スナップショットは、アップストリームリポジトリで使用する場合 Maven リリースバージョンと同じように動作します。しかし、アップストリーム関係にある 2 つのリポジトリに対して同じパッケージバージョンのスナップショットを公開する場合は、制限があります。たとえば、 AWS CodeArtifact ドメインに 2 つのリポジトリがあり、 `R` `U`が のアップストリーム`U`である があるとします`R`。`R` で新しいビルドを公開する場合、Maven クライアントがそのスナップショットバージョンの最新のビルドをリクエストすると、CodeArtifact は `U` から最新バージョンを返します。最新バージョンは `U` ではなく `R` にあるため、これは予期されていない可能性があります。この問題を避けるには、以下の 2 つの方法があります。
1. `U` に `1.0-SNAPSHOT` などのスナップショットバージョンのビルドが存在する場合は、`1.0-SNAPSHOT` を `R` に公開しない。
1. CodeArtifact パッケージオリジンコントロールを使用して、`R` で当該パッケージのアップストリームを無効にする。後者の方法では、`1.0-SNAPSHOT` のビルドを `R` 公開できるようになりますが、その一方で、`U` が保持されていない当該パッケージの他のバージョンを `R` から取得することができなくなります。
# アップストリームと外部接続からの Maven パッケージのリクエスト
## 標準アセット名のインポート
Maven Central などのパブリックリポジトリから Maven パッケージバージョンをインポートする際、AWS CodeArtifact はそのパッケージバージョン内のすべてのアセットのインポートを試みます。「[アップストリームリポジトリを持つパッケージバージョンのリクエスト](repo-upstream-behavior.md)」で説明したように、インポートは次の場合に行われます。
+ クライアントが CodeArtifact リポジトリから Maven アセットをリクエストする。
+ パッケージバージョンはリポジトリにもアップストリームにも存在しない。
+ パブリック Maven リポジトリにアクセス可能な外部接続がある。
クライアントが 1 つのアセットのみをリクエストする場合でも、CodeArtifact はそのパッケージバージョンで見つかったすべてのアセットをインポートしようとします。CodeArtifact が Maven パッケージバージョンで使用できるアセットをどのように検出するかは、パブリックリポジトリによって異なります。一部のパブリック Maven リポジトリは、アセットリストのリクエストをサポートし、別のリポジトリはアセットリストのリクエストをサポートしていません。アセットリストを提供しないリポジトリの場合、CodeArtifact は存在する可能性のあるアセット名のセットを生成します。例えば、Maven パッケージバージョン `junit 4.13.2` のアセットがリクエストされると、CodeArtifact は次のアセットのインポートを試みます。
+ `junit-4.13.2.pom`
+ `junit-4.13.2.jar`
+ `junit-4.13.2-javadoc.jar`
+ `junit-4.13.2-sources.jar`
## 非標準アセット名のインポート
Maven クライアントが上記のパターンのいずれにも一致しないアセットをリクエストすると、CodeArtifact はそのアセットがパブリックリポジトリに存在するかどうかを確認します。アセットが存在する場合、そのアセットはインポートされ、既存のパッケージバージョンレコード (存在する場合) に追加されます。例えば、Maven パッケージバージョン `com.android.tools.build:aapt2 7.3.1-8691043` には以下のアセットが含まれています。
+ `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`
クライアントが POM ファイルをリクエストする際に、CodeArtifact がパッケージバージョンのアセットを一覧表示できない場合、インポートされるアセットは POM のみです。これは、他のどのアセットも標準のアセット名パターンに一致しないためです。ただし、クライアントが JAR アセットの 1 つを要求すると、そのアセットはインポートされ、CodeArtifact に格納されている既存のパッケージバージョンに追加されます。「[アップストリームリポジトリからのパッケージの保持](repo-upstream-behavior.md#package-retention-upstream-repos)」で説明されているように、最も下流のダウンストリームリポジトリ (クライアントがリクエストを行ったリポジトリ) と外部接続がアタッチされているリポジトリの両方のパッケージバージョンが、新しいアセットを含むように更新されます。
通常、パッケージバージョンが CodeArtifact リポジトリに保持されると、アップストリームリポジトリでの変更による影響を受けません。詳細については、「[アップストリームリポジトリからのパッケージの保持](repo-upstream-behavior.md#package-retention-upstream-repos)」を参照してください。ただし、前述した非標準名の Maven アセットの動作は、この規則の例外です。ダウンストリームのパッケージバージョンは、クライアントから追加のアセットをリクエストされない限り変更されませんが、この場合、保持されるパッケージバージョンは最初に保持された後に変更されるため、不変ではありません。非標準名の Maven アセットには CodeArtifact からアクセスできないため、この動作は必要です。この動作は、パッケージバージョンが CodeArtifact リポジトリに保持された後にパブリックリポジトリの Maven パッケージバージョンに追加された場合にも有効になります。
## アセットオリジンの確認
以前保持されていた Maven パッケージバージョンに新しいアセットを追加すると、CodeArtifact は保持されているパッケージバージョンのオリジンが新しいアセットの提供元と同じであることを確認します。これにより、異なるパブリックリポジトリから異なるアセットが発行される「混在」パッケージバージョンの作成を防ぐことができます。このチェックを行わない場合、Maven パッケージのバージョンが複数のパブリックリポジトリに公開され、それらのリポジトリが CodeArtifact リポジトリのアップストリームグラフの一部である場合、アセットが混在する可能性があります。
## アップストリームリポジトリへの新しいアセットのインポートとパッケージバージョンステータスのインポート
アップストリームリポジトリのパッケージバージョンの[パッケージバージョンステータス](packages-overview.md#package-version-status)により、CodeArtifact がそれらのバージョンをダウンストリームリポジトリに保持できなくなることがあります。
例えば、あるドメインに `repo-A`、`repo-B`、および `repo-C` の 3 つのリポジトリがあるとします。ここで、`repo-B` は `repo-A` のアップストリームに、`repo-C` は `repo-B` のアップストリームにあります。
![\[アップストリームリポジトリの新しいアセットとパッケージバージョンがどのように機能するかを示す図。\]](http://docs.aws.amazon.com/ja_jp/codeartifact/latest/ug/images/Maven-new-asset-pv-upstream.png)
Maven パッケージ `com.android.tools.build:aapt2` のパッケージバージョン `7.3.1` は `repo-B` にあり、ステータスは `Published` です。`repo-A` には存在しません。クライアントがこのパッケージバージョンのアセットを `repo-A` からリクエストした場合、レスポンスは 200 (OK) になり、Maven パッケージバージョン `7.3.1` は `repo-A` で保持されます。ただし、`repo-B` のパッケージバージョン `7.3.1` のステータスが `Archived` または `Disposed` の場合、これら 2 つのステータスのパッケージバージョンのアセットはダウンロードできないため、応答は 404 (Not Found) になります。
`com.android.tools.build:aapt2` の [パッケージオリジンコントロール](package-origin-controls.md) を `repo-A` で `upstream=BLOCK` に設定すると、`repo-B` と `repo-C` によってパッケージバージョンのステータスにかかわらず、そのパッケージのすべてのバージョンの新しいアセットは `repo-A` から取得されなくなることに注意してください。
# Maven のトラブルシューティング
以下の情報は、Maven および CodeArtifact での一般的な問題のトラブルシューティングに役立ちます。
## 並列 PUT を無効にして 429: Too Many Requests を修正する
バージョン 3.9.0 以降、Maven はパッケージアーティファクトを並列でアップロードします (一度に最大 5 ファイル)。これにより、CodeArtifact がエラーレスポンスコード 429 (Too Many Requests) で応答することがあります。このエラーは、並列 PUT を無効にすることで修正できます。
並列 PUT を無効にするには、次の例に示すように、`settings.xml` ファイルのプロファイルで `aether.connector.basic.parallelPut` プロパティを `false` に設定します。
```
default
false
```
詳細については、Maven ドキュメントの「[Artifact Resolver Configuration Options](https://maven.apache.org/resolver/configuration.html)」を参照してください。