本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 搭配 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)
+ [搭配 deps.edn 使用 CodeArtifact](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 套件，並將新套件發佈至該儲存庫。
**Topics**
+ [擷取相依性](#fetching-dependencies)
+ [擷取外掛程式](#fetching-plugins)
+ [發佈成品](#publishing-artifacts)
+ [在 IntelliJ IDEA 中執行 Gradle 建置](#gradle-intellij)
## 擷取相依性
若要從 Gradle 組建中的 CodeArtifact 擷取相依性，請使用下列程序。
**在 Gradle 建置中從 CodeArtifact 擷取相依性**
1. 如果您尚未建立 CodeArtifact 驗證權杖，請依照 中的程序，將權杖存放在 環境變數中[使用 環境變數傳遞身分驗證字符](tokens-authentication.md#env-var)。
1. 將`maven`區段新增至專案`build.gradle`檔案中的 `repositories`區段。
```
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 的網域中，使用名為 my\$1repo* 的儲存庫時，命令如下： **
```
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 儲存庫做為專案相依性的唯一來源，`repositories`請從 移除 中的任何其他區段`build.gradle`。如果您有多個儲存庫，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 外掛程式入口網站解析外掛程式](https://plugins.gradle.org/)。若要從 CodeArtifact 儲存庫提取外掛程式，請使用下列程序。
**從 CodeArtifact 儲存庫提取外掛程式**
1. 如果您尚未建立 CodeArtifact 驗證權杖，請依照 中的程序，將權杖存放在 環境變數中[使用 環境變數傳遞身分驗證字符](tokens-authentication.md#env-var)。
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-plugins-store`) 有外部連線的上游儲存庫，以便建置可以使用常用的 Gradle 外掛程式。如需詳細資訊，請參閱 [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` 區段中`version`指定的 `groupId`、 `artifactId`和 產生 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 中執行 Gradle 建置，從 CodeArtifact 提取相依性。若要使用 CodeArtifact 驗證，您必須向 Gradle 提供 CodeArtifact 授權字符。提供身分驗證字符的方法有三種。
+ 方法 1：在 中存放身分驗證字符`gradle.properties`。如果您能夠覆寫或新增至`gradle.properties`檔案的內容，請使用此方法。
+ 方法 2：將身分驗證權杖存放在單獨的檔案中。如果您不想修改`gradle.properties`檔案，請使用此方法。
+ 方法 3：在 中`aws`以內嵌指令碼執行 ，為每次執行產生新的身分驗證權杖`build.gradle`。如果您希望 Gradle 指令碼在每次執行時擷取新的字符，請使用此方法。字符不會存放在檔案系統上。
------
#### [ Token stored in gradle.properties ]
**方法 1：將身分驗證字符存放在 `gradle.properties`**
**注意**
此範例顯示位於 中的 `gradle.properties` 檔案`GRADLE_USER_HOME`。
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 擷取外掛程式，請將 `pluginManagement`區塊新增至 `settings.gradle` 檔案。`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 擷取外掛程式，請將 `pluginManagement`區塊新增至 `settings.gradle` 檔案。`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 擷取外掛程式，請將 `pluginManagement`區塊新增至 `settings.gradle` 檔案。`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
您可以使用 `mvn`命令來執行 Maven 組建。本節說明如何設定 `mvn` 以使用 CodeArtifact 儲存庫。
**Topics**
+ [擷取相依性](#fetching-dependencies)
+ [發佈成品](#publishing-artifacts)
+ [發佈第三方成品](#publishing-third-party-artifacts)
+ [限制 Maven 相依性下載到 CodeArtifact 儲存庫](#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`環境變數的``區段，讓 Maven 在 HTTP 請求中傳遞字符。
```
...
codeartifact
aws
${env.CODEARTIFACT_AUTH_TOKEN}
...
```
1. 在 ``元素中新增 CodeArtifact 儲存庫的 URL 端點。您可以在 `settings.xml`或專案的 POM 檔案中執行此操作。
您可以使用 `get-repository-endpoint` AWS CLI 命令來擷取儲存庫的端點。
例如，在名為 *my\$1domain 的網域中，使用名為 my\$1repo* 的儲存庫時，命令如下所示： **
```
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)
```
## 發佈成品
若要將 Maven 成品發佈`mvn`至 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"
}
]
}
```
## 發佈第三方成品
您可以使用 將第三方 Maven 成品發佈至 CodeArtifact 儲存庫`mvn deploy:deploy-file`。這對於想要發佈成品且只有 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、版本和檔案引數以發佈不同的 JAR。
這些指示是根據指南中的範例[，從 Apache Maven 文件將第三方 JARs 部署到遠端儲存庫](https://maven.apache.org/guides/mini/guide-3rd-party-jars-remote.html)。 **
## 限制 Maven 相依性下載到 CodeArtifact 儲存庫
如果套件無法從設定的儲存庫擷取，依預設，`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`或 中具有 `pluginRepository`元素`pom.xml`。下列範例會從 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)
# 搭配 deps.edn 使用 CodeArtifact
您可以使用 `deps.edn`搭配 `clj` 來管理 Clojure 專案的相依性。本節說明如何設定 `deps.edn` 以使用 CodeArtifact 儲存庫。
**Topics**
+ [擷取相依性](#fetching-dependencies-deps)
+ [發佈成品](#publishing-artifacts-deps)
## 擷取相依性
若要`Clojure`設定 從 CodeArtifact 儲存庫擷取相依性，您必須編輯 Maven 組態檔案 `settings.xml`。
1. 在 中`settings.xml`，新增參考`CODEARTIFACT_AUTH_TOKEN`環境變數的``區段，讓 Clojure 在 HTTP 請求中傳遞字符。
**注意**
Clojure 預期 settings.xml 檔案位於 `~/.m2/settings.xml`。若為其他位置，請在此位置建立 檔案。
```
...
codeartifact
aws
${env.CODEARTIFACT_AUTH_TOKEN}
...
```
1. 如果您還沒有 POM xml，請使用 為您的專案產生 POM xml`clj -Spom`。
1. 在您的`deps.edn`組態檔案中，新增與 Maven 的伺服器 ID 相符的儲存庫`settings.xml`。
```
:mvn/repos {
"clojars" nil
"central" nil
"codeartifact" {:url "https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/"}
}
```
**注意**
`tools.deps` 保證會先檢查 Maven 程式庫的 `central`和 `clojars` 儲存庫。之後，`deps.edn`將檢查 中列出的其他儲存庫。
為了防止直接從 Clojar 和 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`，新增`deploy`任務，將必要的成品上傳到先前的設定`codeartifact`儲存庫。
```
(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 中的[修改預設儲存庫](https://clojure.org/reference/deps_and_cli#_modifying_the_default_repositories)和 CLI 參考原理。 **
# 使用 curl 發佈
本節說明如何使用 HTTP `curl` 用戶端將 Maven 成品發佈至 CodeArtifact 儲存庫。如果您沒有或想要在環境中安裝 Maven 用戶端，使用 發佈成品`curl`會很有用。
**使用 發佈 Maven 成品 `curl`**
1. 遵循中的步驟擷取 CodeArtifact 授權字符，[使用 環境變數傳遞身分驗證字符](tokens-authentication.md#env-var)並返回這些步驟。
1. 使用下列`curl`命令將 JAR 發佈至 CodeArtifact 儲存庫：
在此程序中的每個`curl`命令中，取代下列預留位置：
+ 將 *my\$1domain* 取代為您的 CodeArtifact 網域名稱。
+ 以 CodeArtifact 網域擁有者的 ID 取代 *111122223333*。
+ 將 *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 成品將位於您的 CodeArtifact 儲存庫中，狀態為 `Unfinished`。若要能夠使用套件，它必須處於 `Published` 狀態。您可以透過將`maven-metadata.xml`檔案`Unfinished``Published`上傳至您的套件，或呼叫 [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：`Published`使用 `UpdatePackageVersionsStatus` API 將套件狀態更新為 。
```
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
```
如果您只有成品的 JAR 檔案，則可以使用 將消耗性套件版本發佈至 CodeArtifact 儲存庫`mvn`。如果您無法存取成品的原始碼或 POM，這很有用。如需詳細資訊，請參閱 [發佈第三方成品](maven-mvn.md#publishing-third-party-artifacts)。
# 使用 Maven 檢查總和
當 Maven 成品發佈至 AWS CodeArtifact 儲存庫時，與套件中每個*資產*或檔案相關聯的檢查總和會用來驗證上傳。資產的範例包括 *jar*、*pom* 和 *war* 檔案。對於每個資產，Maven 成品包含多個檢查總和檔案，這些檔案使用資產名稱搭配額外的副檔名，例如 `md5`或 `sha1`。例如，名為 的檔案檢查總和檔案`my-maven-package.jar`可能是 `my-maven-package.jar.md5`和 `my-maven-package.jar.sha1`。
**注意**
Maven 使用 一詞`artifact`。在本指南中，Maven 套件與 Maven 成品相同。如需詳細資訊，請參閱 [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 套件版本上呼叫 ListPackageVersionAssets 的部分回應`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"
}
}
```
即使檢查總和未儲存為資產，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
```
如果您使用 等一般 HTTP 用戶端將現有的 Maven 套件 （例如，先前存放在 Amazon S3 中的套件） 上傳至 CodeArtifact`curl`，則不需要上傳檢查總和。CodeArtifact 會自動產生它們。如果您想要驗證資產是否已正確上傳，您可以使用 ListPackageVersionAssets API 操作，將回應中的檢查總和與每個資產的原始檢查總和值進行比較。
## 發佈期間的檢查總和不相符
除了資產和檢查總和之外，Maven 成品也包含 `maven-metadata.xml` 檔案。Maven 套件的一般發佈順序是先上傳所有資產和檢查總和，接著上傳 `maven-metadata.xml`。例如，假設用戶端設定為發佈 SHA-256 檢查總和檔案，`commons-lang 2.1`前述 Maven 套件版本的發佈順序為：
```
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 （無效的請求）** 回應。如果對應的資產不存在，請求將以 **404 （找不到）** 回應失敗。若要避免此錯誤，您必須先上傳資產，然後上傳檢查總和。
`maven-metadata.xml` 上傳時，CodeArtifact 通常會將 Maven 套件版本的狀態從 變更為 `Unfinished` `Published`。如果偵測到任何資產的檢查總和不相符，CodeArtifact `maven-metadata.xml` 會傳回 **400 （無效的請求）** 以回應發佈請求。此錯誤可能會導致用戶端停止上傳該套件版本的檔案。如果發生這種情況，且`maven-metadata.xml`檔案未上傳，則無法下載已上傳套件版本的任何資產。這是因為套件版本的狀態未設定為 `Published`，且保持 `Unfinished`。
即使`maven-metadata.xml`已上傳且套件版本狀態已設為 ，CodeArtifact 也允許將其他資產新增至 Maven 套件版本`Published`。在此狀態下，上傳不相符檢查總和檔案的請求也會因 **400 （無效的請求）** 回應而失敗。不過，由於套件版本狀態已設為 `Published`，因此您可以從套件下載任何資產，包括檢查總和檔案上傳失敗的資產。在下載檢查總和檔案上傳失敗的資產時，用戶端收到的檢查總和值將是 CodeArtifact 根據上傳的資產資料計算的檢查總和值。
CodeArtifact 檢查總和比較區分大小寫，CodeArtifact 計算的檢查總和格式為小寫。因此，如果`909FA780F76DA393E992A3D2D495F468`上傳檢查總和，則檢查總和不相符會失敗，因為 CodeArtifact 不會將其視為等於 `909fa780f76da393e992a3d2d495f468`。
## 從檢查總和不相符中復原
如果檢查總和上傳因為檢查總和不相符而失敗，請嘗試下列其中一項來復原：
+ 執行再次發佈 Maven 成品的 命令。如果網路問題損毀了檢查總和檔案，這可能會起作用。如果這樣可以解決網路問題，檢查總和會相符且下載成功。
+ 刪除套件版本，然後重新發佈。如需詳細資訊，請參閱 *AWS CodeArtifact API 參考*中的 [DeletePackageVersions](https://docs.aws.amazon.com/dms/latest/APIReference/API_DeletePackageVersions.html)。
# 使用 Maven 快照
Maven *快照*是 Maven 套件的特殊版本，參考最新的生產分支程式碼。這是最終發行版本之前的開發版本。您可以透過附加到套件版本的尾碼`SNAPSHOT`來識別 Maven 套件的快照版本。例如， 版本的快照`1.1`為 `1.1-SNAPSHOT`。如需詳細資訊，請參閱 Apache Maven 專案網站上的[什麼是 SNAPSHOT 版本？](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 套件版本。
例如，名為 的 maven 套件快照版本`com.mycompany.myapp:pkg-1`會上傳至名為 的 CodeArtifact 儲存庫`my-maven-repo`。快照版本為 `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`可以在組建中使用。雖然儲存庫 `com.mycompany.myapp:pkg-1`中有兩個版本的 `my-maven-repo`，但它們都包含相同的資產。
```
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` 參數變更為 的情況下執行先前顯示的相同`list-package-version-assets`命令，`1.0-20210728.194552-1`會產生相同的輸出。
當 的其他組建`1.0-SNAPSHOT`新增至儲存庫時，會為每個新組建建立新的`Unlisted`套件版本。每次`1.0-SNAPSHOT`都會更新 版本的資產，讓版本一律參考該版本的最新組建。`1.0-SNAPSHOT` 使用最新資產更新 是透過上傳新建置`maven-metadata.xml`的檔案來啟動。
## 使用快照版本
如果您請求快照，`Published`則會傳回狀態為 的版本。這一律是 Maven 快照的最新版本。您也可以使用建置版本編號 （例如，`1.0-20210728.194552-1`) 來請求特定建置快照，而不是 URL 路徑中的快照版本 （例如，`1.0-SNAPSHOT`)。若要查看 Maven 快照的建置版本，請使用 CodeArtifact API 指南中的 [ListPackageVersions ](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersions.html) API，並將狀態參數設定為 `Unlisted`。 *CodeArtifact *
## 刪除快照版本
若要刪除 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))，使用 等一般 HTTP 用戶端發佈快照比發佈 Maven 發行版本`curl`更為複雜，如中所述[使用 curl 發佈](maven-curl.md)。請注意，如果您使用 `mvn`或 等 Maven 用戶端建置和部署快照版本，則此區段無關`gradle`。您需要遵循該用戶端的文件。
發佈快照版本涉及發佈一個或多個快照版本的組建。在 CodeArtifact 中，如果有 *n* 個快照版本的組建，將會有 *n \$1 1* 個 CodeArtifact 版本：*n* 個全部組建版本的狀態為 `Unlisted`，以及一個快照版本 （最新發佈的組建） 的狀態為 `Published`。快照版本 （即版本字串包含「-SNAPSHOT」的版本，包含一組與最新發佈組建相同的資產。使用 建立此結構的最簡單方式`curl`如下：
1. 使用 發佈所有建置的所有資產`curl`。
1. 使用 發佈最後一個組建`maven-metadata.xml`的檔案 （即具有最新日期時間戳記的組建）`curl`。這將在版本字串中建立具有「`-SNAPSHOT`」且具有正確資產集的版本。
1. 使用 [UpdatePackageVersionsStatus](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html) API，將所有非最新建置版本的狀態設定為 `Unlisted`。
使用下列`curl`命令來發佈`1.0-SNAPSHOT`套件快照版本的快照資產 （例如 .jar 和 .pom 檔案）`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
```
使用這些範例時：
+ 將 *my\$1domain* 取代為您的 CodeArtifact 網域名稱。
+ 以 CodeArtifact 網域擁有者的 AWS 帳戶 ID 取代 *111122223333*。
+ 將 *us-west-2* 取代 AWS 區域 為您的 CodeArtifact 網域所在的 。
+ 將 *my\$1maven\$1repo* 取代為您的 CodeArtifact 儲存庫名稱。
**重要**
您必須在 `--data-binary` 參數的值前面加上 `@` 字元。將值放入引號時，`@`必須包含在引號內。
您可以為每個組建上傳兩個以上的資產。例如，除了主要 JAR 和 之外，可能還有 Javadoc 和來源 JAR 檔案`pom.xml`。不需要發佈套件版本資產的檢查總和檔案，因為 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` 檔案必須至少參考 ``元素中最新建置版本的其中一個資產。此外，``值必須存在，且必須符合資產檔案名稱中的時間戳記。例如，對於先前發佈的`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`版本有兩個組建，且第一個組建為 `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 發行版本相同，但如果您計劃將相同套件版本的快照發佈到兩個與上游關係的儲存庫，則會有限制。例如，假設 AWS CodeArtifact 網域中有兩個儲存庫，`R`而 `U`，其中 `U`是 的上游`R`。如果您在 中發佈新組建`R`，當 Maven 用戶端請求該快照版本的最新組建時，CodeArtifact 會從 傳回最新版本`U`。這可能是非預期的，因為最新版本現在位於 中`R`，而不是 `U`。有兩種方法可以避免這種情況：
1. 如果 `1.0-SNAPSHOT`中`1.0-SNAPSHOT`存在 `R`，請勿發佈快照版本的組建，例如 。 `U`
1. 使用 CodeArtifact 套件原始伺服器控制，在 中停用該套件上的上游`R`。後者可讓您在 中發佈 的`1.0-SNAPSHOT`組建`R`，但也會`R`防止 從`U`尚未保留的任何其他版本取得該套件。
# 從上游和外部連線請求 Maven 套件
## 匯入標準資產名稱
從公有儲存庫匯入 Maven 套件版本時，例如 Maven Central，AWS CodeArtifact 會嘗試匯入該套件版本中的所有資產。如 中所述[使用上游儲存庫請求套件版本](repo-upstream-behavior.md)，匯入會在下列情況發生：
+ 用戶端從 CodeArtifact 儲存庫請求 Maven 資產。
+ 套件版本尚未存在於儲存庫或其上游。
+ 公有 Maven 儲存庫有可連線的外部連線。
即使用戶端可能只請求一個資產，CodeArtifact 仍會嘗試匯入該套件版本可找到的所有資產。CodeArtifact 如何探索 Maven 套件版本可用的資產取決於特定的公有儲存庫。有些公有 Maven 儲存庫支援請求資產清單，但有些則不支援。對於不提供列出資產方式的儲存庫，CodeArtifact 會產生一組可能存在的資產名稱。例如，當`junit 4.13.2`請求 Maven 套件版本的任何資產時，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 資產時，該資產會匯入並新增至儲存在 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`，其中 `repo-B` 是 `repo-A`和 `repo-C`上游的 upsteam`repo-B`。
![\[新資產和套件版本如何在上游儲存庫中運作的圖表。\]](http://docs.aws.amazon.com/zh_tw/codeartifact/latest/ug/images/Maven-new-asset-pv-upstream.png)
Maven 套件`7.3.1`的套件版本`com.android.tools.build:aapt2`存在於 中，`repo-B`且狀態為 `Published`。它不存在於 中`repo-A`。如果用戶端從 請求此套件版本的資產`repo-A`，回應將是 200 (OK)，而 Maven 套件版本`7.3.1`將保留在 中`repo-A`。不過，如果 `7.3.1`中的套件版本狀態`repo-B`為 `Archived`或 `Disposed`，回應將會是 404 （找不到），因為這兩個狀態的套件版本的資產無法下載。
請注意，在 `repo-A`、 `repo-B`和 `com.android.tools.build:aapt2`中將[套件原始伺服器控制](package-origin-controls.md)設定為 `upstream=BLOCK`，將`repo-C`防止從 擷取該套件所有版本的新資產`repo-A`，無論套件版本狀態為何。
# Maven 疑難排解
以下資訊可協助您對 Maven 和 CodeArtifact 的常見問題進行疑難排解。
## 停用平行放置以修正錯誤 429：請求太多
從 3.9.0 版開始，Maven 會平行上傳套件成品 （一次最多 5 個檔案）。這可能會導致 CodeArtifact 偶爾以錯誤回應代碼 429 （太多請求） 回應。如果您遇到此錯誤，您可以停用平行放置來修正它。
若要停用平行放置，請在 `settings.xml` 檔案中的設定檔`false`中將 `aether.connector.basic.parallelPut` 屬性設定為 ，如下列範例所示：
```
default
false
```
如需詳細資訊，請參閱 Maven 文件中的[成品解析程式組態選項](https://maven.apache.org/resolver/configuration.html)。