Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menggunakan CodeArtifact dengan Maven
Format repositori Maven digunakan oleh banyak bahasa yang berbeda, termasuk Java, Kotlin, Scala, dan Clojure. Ini didukung oleh berbagai alat pembangun, termasuk Maven, Gradle, Scala SBT, Apache Ivy, dan Leiningen.
Kami telah menguji dan mengkonfirmasi kompatibilitas dengan CodeArtifact untuk versi berikut:
+ **Maven** terbaru versi: 3.6.3.
+ **Gradle** terbaru versi: 6.4.1. 5.5.1 juga telah diuji.
+ Versi **Clojure** terbaru: 1.11.1 juga telah diuji.
**Topics**
+ [Gunakan CodeArtifact dengan Gradle](maven-gradle.md)
+ [Gunakan CodeArtifact dengan mvn](maven-mvn.md)
+ [Gunakan CodeArtifact dengan deps.edn](maven-deps.md)
+ [Publikasi dengan curl](maven-curl.md)
+ [Gunakan checksum Maven](maven-checksums.md)
+ [Menggunakan snapshot Maven](maven-snapshots.md)
+ [Meminta paket Maven dari upstream dan koneksi eksternal](maven-upstream-external-connections-request.md)
+ [Pemecahan masalah Maven](maven-troubleshooting.md)
# Gunakan CodeArtifact dengan Gradle
Setelah Anda memiliki token CodeArtifact autentikasi dalam variabel lingkungan seperti yang dijelaskan dalam [Lulus token autentikasi menggunakan variabel lingkungan](tokens-authentication.md#env-var), ikuti petunjuk ini untuk menggunakan paket Maven dari, dan menerbitkan paket baru ke, repositori. CodeArtifact
**Topics**
+ [Mengambil dependensi](#fetching-dependencies)
+ [Mengambil plugin](#fetching-plugins)
+ [Memublikasikan artefak](#publishing-artifacts)
+ [Menjalankan build Gradle di IntelliJ IDEA](#gradle-intellij)
## Mengambil dependensi
Untuk mengambil dependensi dari CodeArtifact build Gradle, gunakan prosedur berikut.
**Untuk mengambil dependensi dari CodeArtifact dalam build Gradle**
1. Jika belum, buat dan simpan token CodeArtifact autentikasi dalam variabel lingkungan dengan mengikuti prosedur di[Teruskan token auth menggunakan variabel lingkungan](tokens-authentication.md#env-var).
1. Tambahkan `maven` bagian ke `repositories` bagian dalam `build.gradle` file proyek.
```
maven {
url 'https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/'
credentials {
username "aws"
password System.env.CODEARTIFACT_AUTH_TOKEN
}
}
```
Contoh `url` sebelumnya adalah titik akhir CodeArtifact repositori Anda. Gradle menggunakan titik akhir untuk terhubung ke repositori Anda. Dalam sampel, `my_domain` adalah nama domain Anda, `111122223333` adalah ID pemilik domain, dan `my_repo` adalah nama repositori Anda. Anda dapat mengambil titik akhir repositori dengan menggunakan perintah. `get-repository-endpoint` AWS CLI
Misalnya, dengan repositori bernama *my\$1repo* di dalam domain bernama*my\$1domain*, perintahnya adalah sebagai berikut:
```
aws codeartifact get-repository-endpoint --domain my_domain --domain-owner 111122223333 --repository my_repo --format maven
```
Parameter perintah `get-repository-endpoint` akan mengembalikan titik akhir repositori:
```
url 'https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/'
```
`credentials`Objek dalam contoh sebelumnya menyertakan token CodeArtifact autentikasi yang Anda buat di Langkah 1 yang digunakan Gradle untuk mengautentikasi. CodeArtifact
**catatan**
Untuk menggunakan endpoint dualstack, gunakan endpoint. `codeartifact.region.on.aws`
1. (Opsional) - Untuk menggunakan CodeArtifact repositori sebagai satu-satunya sumber untuk dependensi proyek Anda, hapus bagian lain dari. `repositories` `build.gradle` Jika Anda memiliki lebih dari satu repositori, Gradle menelusuri setiap repositori untuk dependensi sesuai urutan pencantumannya.
1. Setelah mengonfigurasi repositori, Anda dapat menambahkan dependensi proyek ke bagian `dependencies` dengan sintaks Gradle standar.
```
dependencies {
implementation 'com.google.guava:guava:27.1-jre'
implementation 'commons-cli:commons-cli:1.4'
testImplementation 'org.testng:testng:6.14.3'
}
```
## Mengambil plugin
Secara default Gradle akan menyelesaikan plugin dari [Portal Plugin Gradle](https://plugins.gradle.org/) publik. Untuk menarik plugin dari CodeArtifact repositori, gunakan prosedur berikut.
**Untuk menarik plugin dari repositori CodeArtifact**
1. Jika belum, buat dan simpan token CodeArtifact autentikasi dalam variabel lingkungan dengan mengikuti prosedur di[Teruskan token auth menggunakan variabel lingkungan](tokens-authentication.md#env-var).
1. Tambahkan `pluginManagement` blok ke `settings.gradle` file Anda. `pluginManagement`Blok harus muncul sebelum pernyataan lain di`settings.gradle`, lihat cuplikan berikut:
```
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
}
}
}
}
```
Hal ini akan memastikan bahwa Gradle menyelesaikan plugin dari repositori yang ditentukan. Repositori harus memiliki repositori hulu dengan koneksi eksternal ke Portal Plugin Gradle (mis. `gradle-plugins-store`) sehingga plugin Gradle yang umum diperlukan tersedia untuk build. Untuk informasi selengkapnya, lihat [Dokumentasi Gradle](https://docs.gradle.org/current/userguide/plugins.html#sec:custom_plugin_repositories).
## Memublikasikan artefak
Bagian ini menjelaskan cara mempublikasikan pustaka Java yang dibangun dengan Gradle ke CodeArtifact repositori.
Pertama, tambahkan plugin `maven-publish` ke bagian `plugins` dari file `build.gradle` proyek.
```
plugins {
id 'java-library'
id 'maven-publish'
}
```
Selanjutnya, tambahkan bagian `publishing` ke file `build.gradle` proyek.
```
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
}
}
}
}
```
Plugin `maven-publish` menghasilkan file POM berdasarkan `groupId`, `artifactId`, dan `version` yang ditentukan dalam bagian `publishing`.
Setelah perubahan ke `build.gradle` selesai, jalankan perintah berikut untuk membangun proyek dan mengunggah ke repositori.
```
./gradlew publish
```
Gunakan `list-package-versions` untuk memeriksa bahwa paket berhasil dipublikasikan.
```
aws codeartifact list-package-versions --domain my_domain --domain-owner 111122223333 --repository my_repo --format maven\
--namespace com.company.framework --package my-package-name
```
Contoh output:
```
{
"format": "maven",
"namespace": "com.company.framework",
"package": "example",
"versions": [
{
"version": "1.0",
"revision": "REVISION-SAMPLE-1-C7F4S5E9B772FC",
"status": "Published"
}
]
}
```
Untuk informasi selengkapnya, lihat topik berikut di situs web Gradle:
+ [Membangun Perpustakaan Java](https://guides.gradle.org/building-java-libraries/)
+ [Menerbitkan proyek sebagai modul](https://docs.gradle.org/current/userguide/publishing_setup.html)
## Menjalankan build Gradle di IntelliJ IDEA
Anda dapat menjalankan build Gradle di IntelliJ IDEA yang menarik dependensi dari. CodeArtifact Untuk mengautentikasi CodeArtifact, Anda harus memberikan token CodeArtifact otorisasi kepada Gradle. Ada tiga metode untuk menyediakan token autentikasi.
+ Metode 1: Menyimpan token autentikasi di`gradle.properties`. Gunakan metode ini jika Anda dapat menimpa atau menambah isi `gradle.properties` file.
+ Metode 2: Menyimpan token autentikasi dalam file terpisah. Gunakan metode ini jika Anda tidak ingin memodifikasi file `gradle.properties`.
+ Metode 3: Menghasilkan token autentikasi baru untuk setiap proses dengan menjalankan `aws` sebagai skrip inline di. `build.gradle` Gunakan metode ini jika Anda ingin skrip Gradle mengambil token baru pada setiap proses. Token tidak akan disimpan di sistem file.
------
#### [ Token stored in gradle.properties ]
**Metode 1: Menyimpan token autentikasi di `gradle.properties`**
**catatan**
Contoh menunjukkan file `gradle.properties` yang berada di `GRADLE_USER_HOME`.
1. Perbarui file `build.gradle` dengan cuplikan berikut:
```
repositories {
maven {
url 'https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/'
credentials {
username "aws"
password "$codeartifactToken"
}
}
}
```
1. Untuk mengambil plugin dari CodeArtifact, tambahkan `pluginManagement` blok ke file Anda`settings.gradle`. `pluginManagement`Blok harus muncul sebelum pernyataan lain di`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. Ambil token CodeArtifact autentikasi:
```
export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token --domain my_domain --domain-owner 111122223333 --query authorizationToken --output text --profile profile-name`
```
1. Tulis token auth ke dalam file `gradle.properties`:
```
echo "codeartifactToken=$CODEARTIFACT_AUTH_TOKEN" > ~/.gradle/gradle.properties
```
------
#### [ Token stored in separate file ]
**Metode 2: Menyimpan token autentikasi dalam file terpisah**
1. Perbarui file `build.gradle` dengan cuplikan berikut:
```
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. Untuk mengambil plugin dari CodeArtifact, tambahkan `pluginManagement` blok ke file Anda`settings.gradle`. `pluginManagement`Blok harus muncul sebelum pernyataan lain di`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. Ambil token CodeArtifact autentikasi:
```
export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token --domain my_domain --domain-owner 111122223333 --query authorizationToken --output text --profile profile-name`
```
1. Tulis token auth ke dalam file yang ditentukan dalam file `build.gradle` Anda:
```
echo "codeartifactToken=$CODEARTIFACT_AUTH_TOKEN" > file
```
------
#### [ Token generated for each run in build.gradle ]
**Metode 3: Menghasilkan token autentikasi baru untuk setiap proses dengan menjalankan `aws` sebagai skrip sebaris di `build.gradle`**
1. Perbarui file `build.gradle` dengan cuplikan berikut:
```
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. Untuk mengambil plugin dari CodeArtifact, tambahkan `pluginManagement` blok ke file Anda`settings.gradle`. `pluginManagement`Blok harus muncul sebelum pernyataan lain di`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
}
}
}
}
```
------
# Gunakan CodeArtifact dengan mvn
Anda menggunakan perintah `mvn` untuk mengeksekusi build Maven. Bagian ini menunjukkan cara mengkonfigurasi `mvn` untuk menggunakan CodeArtifact repositori.
**Topics**
+ [Mengambil dependensi](#fetching-dependencies)
+ [Memublikasikan artefak](#publishing-artifacts)
+ [Memublikasikan artefak pihak ketiga](#publishing-third-party-artifacts)
+ [Batasi unduhan ketergantungan Maven ke repositori CodeArtifact](#restrict-maven-downloads)
+ [Informasi Proyek Apache Maven](#apache-maven-project-info)
## Mengambil dependensi
Untuk mengonfigurasi `mvn` untuk mengambil dependensi dari CodeArtifact repositori, Anda harus mengedit file konfigurasi Maven, dan secara opsional`settings.xml`, POM proyek Anda.
1. Jika belum, buat dan simpan token CodeArtifact autentikasi dalam variabel lingkungan seperti yang dijelaskan [Teruskan token auth menggunakan variabel lingkungan](tokens-authentication.md#env-var) untuk menyiapkan otentikasi ke repositori Anda CodeArtifact .
1. Dalam `settings.xml` (biasanya ditemukan di `~/.m2/settings.xml`), tambahkan bagian `` dengan referensi ke variabel lingkungan `CODEARTIFACT_AUTH_TOKEN` sehingga Maven meneruskan token dalam permintaan HTTP.
```
...
codeartifact
aws
${env.CODEARTIFACT_AUTH_TOKEN}
...
```
1. Tambahkan titik akhir URL untuk CodeArtifact repositori Anda dalam sebuah elemen. `` Anda dapat melakukan hal ini di `settings.xml` atau file POM proyek Anda.
Anda dapat mengambil endpoint repositori Anda dengan menggunakan perintah. `get-repository-endpoint` AWS CLI
Misalnya, dengan repositori bernama *my\$1repo* di dalam domain bernama*my\$1domain*, perintahnya adalah sebagai berikut:
```
aws codeartifact get-repository-endpoint --domain my_domain --repository my_repo --format maven
```
Parameter perintah `get-repository-endpoint` akan mengembalikan titik akhir repositori:
```
url 'https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/'
```
**catatan**
Untuk menggunakan endpoint dualstack, gunakan endpoint. `codeartifact.region.on.aws`
Tambahkan titik akhir repositori ke `settings.xml` sebagai berikut.
```
...
default
codeartifact
https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/
default
...
```
Atau, Anda dapat menambahkan `` bagian ke file POM proyek untuk digunakan hanya CodeArtifact untuk proyek itu.
```
...
codeartifact
codeartifact
https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/
...
```
**penting**
Anda dapat menggunakan nilai apa pun dalam elemen ``, tetapi harus sama di elemen `` dan ``. Hal ini memungkinkan kredensi yang ditentukan untuk dimasukkan dalam permintaan untuk. CodeArtifact
Setelah membuat perubahan konfigurasi ini, Anda dapat membangun proyek.
```
mvn compile
```
Maven mencatat URL lengkap dari semua dependensi yang diunduhnya ke konsol.
```
[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)
```
## Memublikasikan artefak
Untuk mempublikasikan artefak Maven dengan `mvn` ke CodeArtifact repositori, Anda juga harus mengedit `~/.m2/settings.xml` dan proyek POM.
1. Jika belum, buat dan simpan token CodeArtifact autentikasi dalam variabel lingkungan seperti yang dijelaskan [Teruskan token auth menggunakan variabel lingkungan](tokens-authentication.md#env-var) untuk menyiapkan otentikasi ke repositori Anda CodeArtifact .
1. Tambahkan bagian `` ke `settings.xml`dengan referensi ke variabel lingkungan `CODEARTIFACT_AUTH_TOKEN` sehingga Maven meneruskan token dalam permintaan HTTP.
```
...
codeartifact
aws
${env.CODEARTIFACT_AUTH_TOKEN}
...
```
1. Tambahkan bagian `` ke `pom.xml`.
```
...
codeartifact
codeartifact
https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/
...
```
Setelah membuat perubahan konfigurasi ini, Anda dapat membangun proyek dan memublikasikannya ke repositori yang ditentukan.
```
mvn deploy
```
Gunakan `list-package-versions` untuk memeriksa bahwa paket berhasil dipublikasikan.
```
aws codeartifact list-package-versions --domain my_domain --domain-owner 111122223333 --repository my_repo --format maven \
--namespace com.company.framework --package my-package-name
```
Contoh output:
```
{
"defaultDisplayVersion": null,
"format": "maven",
"namespace": "com.company.framework",
"package": "my-package-name",
"versions": [
{
"version": "1.0",
"revision": "REVISION-SAMPLE-1-C7F4S5E9B772FC",
"status": "Published"
}
]
}
```
## Memublikasikan artefak pihak ketiga
Anda dapat mempublikasikan artefak Maven pihak ketiga ke repositori dengan CodeArtifact . `mvn deploy:deploy-file` Hal ini dapat membantu pengguna yang ingin memublikasikan artefak dan hanya memiliki file JAR dan tidak memiliki akses ke kode sumber paket atau file POM.
Perintah `mvn deploy:deploy-file` akan menghasilkan file POM berdasarkan informasi yang dikirimkan pada baris perintah.
**Memublikasikan artefak Maven pihak ketiga**
1. Jika belum, buat dan simpan token CodeArtifact autentikasi dalam variabel lingkungan seperti yang dijelaskan [Teruskan token auth menggunakan variabel lingkungan](tokens-authentication.md#env-var) untuk menyiapkan otentikasi ke repositori Anda CodeArtifact .
1. Buat file `~/.m2/settings.xml` dengan konten berikut ini:
```
codeartifact
aws
${env.CODEARTIFACT_AUTH_TOKEN}
```
1. Jalankan perintah `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/
```
**catatan**
Contoh di atas memublikasikan `commons-cli 1.4`. Ubah groupId, artifactID, versi, dan file argumen untuk memublikasikan JAR yang berbeda.
Instruksi ini didasarkan pada contoh dalam [Panduan untuk menyebarkan pihak JARs ke-3 ke repositori jarak jauh](https://maven.apache.org/guides/mini/guide-3rd-party-jars-remote.html) dari dokumentasi *Apache* Maven.
## Batasi unduhan ketergantungan Maven ke repositori CodeArtifact
Jika paket tidak dapat diambil dari repositori yang dikonfigurasi, secara default, perintah `mvn` mengambilnya dari Maven Central. Tambahkan `mirrors` elemen `settings.xml` untuk membuat `mvn` selalu menggunakan CodeArtifact repositori Anda.
```
...
central-mirror
CodeArtifact Maven Central mirror
https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/
central
...
```
Jika Anda menambahkan elemen `mirrors`, Anda juga harus memiliki elemen `pluginRepository` di `settings.xml` atau `pom.xml`. Contoh berikut mengambil dependensi aplikasi dan plugin Maven dari repositori. CodeArtifact
```
...
codeartifact
CodeArtifact Plugins
https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/
true
true
...
```
Contoh berikut mengambil dependensi aplikasi dari CodeArtifact repositori dan mengambil plugin Maven dari Maven Central.
```
default
...
central-plugins
Central Plugins
https://repo.maven.apache.org/maven2/
true
true
....
```
## Informasi Proyek Apache Maven
Untuk informasi lebih lanjut tentang Maven, lihat topik ini di situs web Apache Maven Project:
+ [Menyiapkan Beberapa Repositori](https://maven.apache.org/guides/mini/guide-multiple-repositories.html)
+ [Pengaturan Referensi](https://maven.apache.org/settings.html)
+ [Manajemen Distribusi](https://maven.apache.org/pom.html#Distribution_Management)
+ [Profil](https://maven.apache.org/pom.html#Profiles)
# Gunakan CodeArtifact dengan deps.edn
Anda menggunakan `deps.edn` with `clj` untuk mengelola dependensi untuk proyek Clojure. Bagian ini menunjukkan cara mengkonfigurasi `deps.edn` untuk menggunakan CodeArtifact repositori.
**Topics**
+ [Mengambil dependensi](#fetching-dependencies-deps)
+ [Memublikasikan artefak](#publishing-artifacts-deps)
## Mengambil dependensi
Untuk mengkonfigurasi `Clojure` untuk mengambil dependensi dari CodeArtifact repositori, Anda harus mengedit file konfigurasi Maven,. `settings.xml`
1. Di`settings.xml`, tambahkan `` bagian dengan referensi ke variabel `CODEARTIFACT_AUTH_TOKEN` lingkungan sehingga Clojure melewati token dalam permintaan HTTP.
**catatan**
Clojure mengharapkan file settings.xml berada di. `~/.m2/settings.xml` Jika di tempat lain, buat file di lokasi ini.
```
...
codeartifact
aws
${env.CODEARTIFACT_AUTH_TOKEN}
...
```
1. Jika Anda belum memilikinya, buat POM xmluntuk proyek Anda menggunakan. `clj -Spom`
1. Dalam file `deps.edn` konfigurasi Anda, tambahkan repositori yang cocok dengan id server dari 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/"}
}
```
**catatan**
`tools.deps`menjamin bahwa `central` dan `clojars` repositori akan diperiksa terlebih dahulu untuk perpustakaan Maven. Setelah itu, repositori lain yang terdaftar `deps.edn` akan diperiksa.
Untuk mencegah pengunduhan dari Clojars dan Maven Central secara langsung, `central` dan `clojars` perlu diatur ke. `nil`
Pastikan Anda memiliki token CodeArtifact Auth dalam variabel lingkungan (lihat[Teruskan token auth menggunakan variabel lingkungan](tokens-authentication.md#env-var)). Saat membangun paket setelah perubahan ini, dependensi di `deps.edn` akan diambil dari. CodeArtifact
**catatan**
Untuk menggunakan endpoint dualstack, gunakan endpoint. `codeartifact.region.on.aws`
## Memublikasikan artefak
1. Perbarui pengaturan Maven Anda dan `deps.edn` sertakan CodeArtifact sebagai server yang diakui maven (lihat). [Mengambil dependensi](#fetching-dependencies-deps) Anda dapat menggunakan alat seperti [deps-deploy](https://github.com/slipset/deps-deploy) untuk mengunggah artefak. CodeArtifact
1. Di Anda`build.clj`, tambahkan `deploy` tugas untuk mengunggah artefak yang diperlukan ke `codeartifact` repositori penyiapan sebelumnya.
```
(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. Publikasikan artefak dengan menjalankan perintah: `clj -T:build deploy`
*Untuk informasi selengkapnya tentang memodifikasi repositori default, lihat [Memodifikasi repositori default di Clojure Deps dan Rasional](https://clojure.org/reference/deps_and_cli#_modifying_the_default_repositories) Referensi CLI.*
# Publikasi dengan curl
Bagian ini menunjukkan cara menggunakan klien `curl` HTTP untuk mempublikasikan artefak Maven ke repositori. CodeArtifact Memublikasikan artefak dengan `curl` dapat berguna jika Anda tidak memiliki atau ingin menginstal klien Maven di lingkungan Anda.
**Memublikasikan artefak Maven dengan `curl`**
1. Ambil token CodeArtifact otorisasi dengan mengikuti langkah-langkah masuk [Teruskan token auth menggunakan variabel lingkungan](tokens-authentication.md#env-var) dan kembali ke langkah-langkah ini.
1. Gunakan `curl` perintah berikut untuk mempublikasikan JAR ke CodeArtifact repositori:
Di setiap `curl` perintah dalam prosedur ini, ganti placeholder berikut:
+ Ganti *my\$1domain* dengan nama CodeArtifact domain Anda.
+ Ganti *111122223333* dengan ID pemilik CodeArtifact domain Anda.
+ Ganti *us-west-2* dengan wilayah tempat CodeArtifact domain Anda berada.
+ Ganti *my\$1repo* dengan nama CodeArtifact repositori Anda.
```
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
```
**penting**
Anda harus mengawali nilai `--data-binary` parameter dengan `@` karakter. Saat memasukkan nilai dalam tanda kutip, `@` harus disertakan di dalam tanda kutip.
1. Gunakan `curl` perintah berikut untuk mempublikasikan POM ke CodeArtifact repositori:
```
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. Pada titik ini, artefak Maven akan berada di CodeArtifact repositori Anda dengan status. `Unfinished` Untuk dapat menggunakan paket, artefak tersebut harus berstatus `Published`. Anda dapat memindahkan paket dari `Unfinished` ke `Published` dengan mengunggah `maven-metadata.xml` file ke paket Anda, atau memanggil [UpdatePackageVersionsStatus API](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html) untuk mengubah status.
1. Opsi 1: Gunakan perintah `curl` berikut untuk menambahkan file `maven-metadata.xml` ke paket Anda:
```
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
```
Berikut ini adalah contoh isi file `maven-metadata.xml`:
```
com.mycompany.app
my-app
1.0
1.0
1.0
20200731090423
```
1. Opsi 2: Memperbarui status paket ke `Published` dengan 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
```
Jika Anda hanya memiliki file JAR artefak, Anda dapat mempublikasikan versi paket habis pakai ke CodeArtifact repositori menggunakan. `mvn` Hal ini dapat berguna jika Anda tidak memiliki akses ke kode sumber artefak atau POM. Lihat [Memublikasikan artefak pihak ketiga](maven-mvn.md#publishing-third-party-artifacts) untuk rincian selengkapnya.
# Gunakan checksum Maven
Ketika artefak Maven dipublikasikan ke AWS CodeArtifact repositori, checksum yang terkait dengan setiap *aset* atau file dalam paket digunakan untuk memvalidasi unggahan. Contoh aset adalah file *jar*, *pom*, dan *war*. Untuk setiap aset, artefak Maven berisi beberapa file checksum yang menggunakan nama aset dengan ekstensi tambahan, seperti `md5` atau `sha1`. Sebagai contoh, file checksum untuk file bernama `my-maven-package.jar` mungkin `my-maven-package.jar.md5` dan `my-maven-package.jar.sha1`.
**catatan**
Maven menggunakan istilah `artifact`. Dalam panduan ini, paket Maven sama dengan artefak Maven. Untuk informasi lebih lanjut, lihat [AWS CodeArtifactpaket](https://docs.aws.amazon.com/codeartifact/latest/ug/welcome.html#welcome-concepts-package).
## Penyimpanan Checksum
CodeArtifact tidak menyimpan checksum Maven sebagai aset. [Ini berarti bahwa checksum tidak muncul sebagai aset individual dalam output API. ListPackageVersionAssets ](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersionAssets.html) Sebagai gantinya, checksum yang dihitung oleh CodeArtifact tersedia untuk setiap aset di semua jenis checksum yang didukung. Misalnya, bagian dari respons panggilan ListPackageVersionAssets pada versi `commons-lang:commons-lang 2.1` paket Maven adalah:
```
{
"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"
}
}
```
Meskipun checksum tidak disimpan sebagai aset, klien Maven masih dapat mempublikasikan dan mengunduh checksum di lokasi yang diharapkan. Misalnya, jika `commons-lang:commons-lang 2.1` berada di repositori yang disebut`maven-repo`, jalur URL untuk checksum SHA-256 dari file JAR adalah:
```
/maven/maven-repo/commons-lang/commons-lang/2.1/commons-lang-2.1.jar.sha256
```
Jika Anda mengunggah paket Maven yang ada (misalnya, paket yang sebelumnya disimpan di Amazon S3) untuk CodeArtifact menggunakan klien HTTP generik seperti`curl`, tidak perlu mengunggah checksum. CodeArtifact akan menghasilkannya secara otomatis. Jika ingin memverifikasi bahwa aset telah diunggah dengan benar, Anda dapat menggunakan operasi ListPackageVersionAssets API untuk membandingkan checksum dalam respons terhadap nilai checksum asli untuk setiap aset.
## Ketidakcocokan checksum selama penerbitan
Selain aset dan checksum, artefak Maven juga berisi file. `maven-metadata.xml` Urutan penerbitan normal untuk paket Maven adalah untuk semua aset dan checksum yang akan diunggah terlebih dahulu, diikuti oleh. `maven-metadata.xml` Misalnya, urutan penerbitan untuk versi paket Maven yang `commons-lang 2.1` dijelaskan sebelumnya, dengan asumsi klien dikonfigurasi untuk menerbitkan file checksum SHA-256, adalah:
```
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
```
Saat mengunggah file checksum untuk aset, seperti file JAR, permintaan unggahan checksum akan gagal dengan respons **400 (Permintaan Buruk)** jika ada ketidakcocokan antara nilai checksum yang diunggah dan nilai checksum yang dihitung oleh. CodeArtifact Jika aset terkait tidak ada, permintaan akan gagal dengan respons **404 (Tidak Ditemukan)**. Untuk menghindari kesalahan ini, Anda harus mengunggah aset terlebih dahulu, lalu mengunggah checksum.
Ketika `maven-metadata.xml` diunggah, CodeArtifact biasanya mengubah status versi paket Maven dari ke. `Unfinished` `Published` Jika ketidakcocokan checksum terdeteksi untuk aset apa pun, CodeArtifact akan mengembalikan **400 (Permintaan Buruk) sebagai tanggapan atas permintaan** `maven-metadata.xml` penerbitan. Kesalahan ini dapat menyebabkan klien berhenti mengunggah file untuk versi paket tersebut. Jika ini terjadi, dan `maven-metadata.xml` file tidak diunggah, aset apa pun dari versi paket yang sudah diunggah tidak dapat diunduh. Ini karena status versi paket tidak disetel ke `Published` dan tetap ada`Unfinished`.
CodeArtifact memungkinkan penambahan aset lebih lanjut ke versi paket Maven bahkan setelah `maven-metadata.xml` diunggah dan status versi paket telah disetel ke. `Published` Dalam status ini, permintaan untuk mengunggah file checksum yang tidak cocok juga akan gagal dengan respons **400 (Permintaan Buruk)**. Namun, karena status versi paket telah disetel ke`Published`, Anda dapat mengunduh aset apa pun dari paket, termasuk aset yang gagal diunggah file checksum. Saat mengunduh checksum untuk aset di mana unggahan file checksum gagal, nilai checksum yang diterima klien akan menjadi nilai checksum yang dihitung CodeArtifact berdasarkan data aset yang diunggah.
CodeArtifact perbandingan checksum peka huruf besar/kecil, dan checksum yang dihitung oleh CodeArtifact diformat dalam huruf kecil. Oleh karena itu, jika checksum `909FA780F76DA393E992A3D2D495F468` diunggah, itu akan gagal dengan ketidakcocokan checksum karena CodeArtifact tidak memperlakukannya sama dengan. `909fa780f76da393e992a3d2d495f468`
## Memulihkan dari ketidakcocokan checksum
Jika unggahan checksum gagal karena ketidakcocokan checksum, coba salah satu dari berikut ini untuk memulihkan:
+ Jalankan perintah yang menerbitkan artefak Maven lagi. Ini mungkin berfungsi jika masalah jaringan merusak file checksum. Jika ini menyelesaikan masalah jaringan, checksum cocok dan unduhan berhasil.
+ Hapus versi paket dan kemudian publikasikan ulang. Untuk informasi selengkapnya, lihat [DeletePackageVersions](https://docs.aws.amazon.com/dms/latest/APIReference/API_DeletePackageVersions.html)di *AWS CodeArtifact API Referensi*.
# Menggunakan snapshot Maven
*Snapshot* Maven adalah versi khusus dari paket Maven yang mengacu pada kode cabang produksi terbaru. Ini adalah versi pengembangan sebelum versi rilis akhir. Anda dapat mengidentifikasi versi snapshot dari paket Maven dengan akhiran `SNAPSHOT` yang ditambahkan ke versi paket. Sebagai contoh, snapshot versi `1.1` adalah `1.1-SNAPSHOT`. Untuk informasi selengkapnya, lihat [What is a SNAPSHOT version?](https://maven.apache.org/guides/getting-started/index.html#What_is_a_SNAPSHOT_version) di situs Apache Maven Project.
AWS CodeArtifact mendukung penerbitan dan penggunaan snapshot Maven. Snapshot unik yang menggunakan nomor versi berbasis waktu adalah satu-satunya snapshot yang didukung. CodeArtifact tidak mendukung snapshot non-unik yang dihasilkan oleh klien Maven 2. Anda dapat mempublikasikan snapshot Maven yang didukung ke repositori apa pun. CodeArtifact
**Topics**
+ [Penerbitan snapshot di CodeArtifact](#maven-snapshot-publishing)
+ [Mengkonsumsi versi snapshot](#maven-consuming-snapshot-versions)
+ [Menghapus versi snapshot](#maven-deleting-snapshot-versions)
+ [Penerbitan snapshot dengan curl](#maven-snapshot-publishing-curl)
+ [Snapshot dan koneksi eksternal](#maven-snapshot-external-connections)
+ [Snapshot dan repositori upstream](#maven-snapshot-upstream-repositories)
## Penerbitan snapshot di CodeArtifact
AWS CodeArtifact mendukung pola permintaan yang digunakan klien, seperti`mvn`, saat menerbitkan snapshot. Karena itu, Anda dapat mengikuti dokumentasi untuk alat build atau pengelola paket Anda tanpa memiliki pemahaman mendetail tentang bagaimana snapshot Maven dipublikasikan. Jika Anda melakukan sesuatu yang lebih kompleks, bagian ini menjelaskan secara rinci bagaimana CodeArtifact menangani snapshot.
Ketika snapshot Maven dipublikasikan ke CodeArtifact repositori, versi sebelumnya dipertahankan dalam versi baru yang disebut build. Setiap kali snapshot Maven dipublikasikan, versi build baru dibuat. Semua versi snapshot sebelumnya dipertahankan dalam versi build. Saat snapshot Maven diterbitkan, status versi paketnya disetel ke `Published` dan status build yang berisi versi sebelumnya disetel ke. `Unlisted` Perilaku ini hanya berlaku untuk versi paket Maven di mana versi paket memiliki `-SNAPSHOT` akhiran.
Misalnya, versi snapshot dari paket maven yang dipanggil diunggah ke `com.mycompany.myapp:pkg-1` repositori yang dipanggil. CodeArtifact `my-maven-repo` Versi snapshot adalah`1.0-SNAPSHOT`. Sejauh ini, `com.mycompany.myapp:pkg-1` belum ada versi yang diterbitkan. Pertama, aset build awal dipublikasikan di jalur ini:
```
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
```
Perhatikan bahwa stempel waktu `20210728.194552-1` dihasilkan oleh klien yang menerbitkan build snapshot.
Setelah file.pom dan .jar diunggah, satu-satunya versi `com.mycompany.myapp:pkg-1` yang ada di repositori adalah. `1.0-20210728.194552-1` Ini terjadi meskipun versi yang ditentukan di jalur sebelumnya adalah. `1.0-SNAPSHOT` Status versi paket pada saat ini adalah`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"
}
```
Selanjutnya, klien mengunggah `maven-metadata.xml` file untuk versi paket:
```
PUT my-maven-repo/com/mycompany/myapp/pkg-1/1.0-SNAPSHOT/maven-metadata.xml
```
Ketika file maven-metadata.xml berhasil diunggah, CodeArtifact buat versi `1.0-SNAPSHOT` paket dan atur `1.0-20210728.194552-1` versinya. `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"
}
```
Pada titik ini, versi snapshot `1.0-SNAPSHOT` dapat dikonsumsi dalam build. Meskipun ada dua versi `com.mycompany.myapp:pkg-1` dalam repositori`my-maven-repo`, keduanya mengandung aset yang sama.
```
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"
]
```
Menjalankan `list-package-version-assets` perintah yang sama seperti yang ditunjukkan sebelumnya dengan `--package-version` parameter diubah untuk `1.0-20210728.194552-1` menghasilkan output yang identik.
Karena build tambahan `1.0-SNAPSHOT` ditambahkan ke repositori, versi `Unlisted` paket baru dibuat untuk setiap build baru. Aset versi `1.0-SNAPSHOT` diperbarui setiap kali sehingga versi selalu mengacu pada versi terbaru untuk versi tersebut. Memperbarui `1.0-SNAPSHOT` dengan aset terbaru dimulai dengan mengunggah `maven-metadata.xml` file untuk build baru.
## Mengkonsumsi versi snapshot
Jika Anda meminta snapshot, versi dengan status `Published` dikembalikan. Ini selalu merupakan versi terbaru snapshot Maven. Anda juga dapat meminta build snapshot tertentu menggunakan nomor versi build (misalnya,`1.0-20210728.194552-1`) alih-alih versi snapshot (misalnya,`1.0-SNAPSHOT`) di jalur URL. Untuk melihat versi build snapshot Maven, gunakan [ListPackageVersions ](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersions.html)API di *Panduan CodeArtifact API* dan setel parameter status ke. `Unlisted`
## Menghapus versi snapshot
Untuk menghapus semua versi build snapshot Maven, gunakan [DeletePackageVersions](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_DeletePackageVersions.html)API, tentukan versi yang ingin Anda hapus.
## Penerbitan snapshot dengan curl
Jika Anda memiliki versi snapshot yang disimpan di Amazon Simple Storage Service (Amazon S3) atau produk repositori artefak lainnya, Anda mungkin ingin mempublikasikannya kembali. AWS CodeArtifact Karena cara CodeArtifact mendukung snapshot Maven (lihat[Penerbitan snapshot di CodeArtifact](#maven-snapshot-publishing)), menerbitkan snapshot dengan klien HTTP generik seperti lebih kompleks daripada menerbitkan versi rilis `curl` Maven seperti yang dijelaskan dalam. [Publikasi dengan curl](maven-curl.md) Perhatikan bahwa bagian ini tidak relevan jika Anda membuat dan menerapkan versi snapshot dengan klien Maven seperti atau. `mvn` `gradle` Anda harus mengikuti dokumentasi untuk klien itu.
Menerbitkan versi snapshot melibatkan penerbitan satu atau beberapa build versi snapshot. Di CodeArtifact, jika ada *n* build dari versi snapshot, akan ada *n \$1 1* CodeArtifact versi: *n* versi build semua dengan status`Unlisted`, dan satu versi snapshot (build terbaru yang diterbitkan) dengan status. `Published` Versi snapshot (yaitu, versi dengan string versi yang berisi “-SNAPSHOT”) berisi kumpulan aset yang identik dengan build terbaru yang diterbitkan. Cara paling sederhana untuk membuat struktur ini menggunakan `curl` adalah sebagai berikut:
1. Publikasikan semua aset dari semua build menggunakan`curl`.
1. Publikasikan `maven-metadata.xml` file build terakhir (yaitu, build dengan stempel tanggal-waktu terbaru) dengan. `curl` Ini akan membuat versi dengan “`-SNAPSHOT`” dalam string versi dan dengan set aset yang benar.
1. Gunakan [UpdatePackageVersionsStatus](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html)API untuk menyetel status semua versi build yang tidak terbaru. `Unlisted`
Gunakan `curl` perintah berikut untuk mempublikasikan aset snapshot (seperti file.jar dan .pom) untuk versi snapshot dari sebuah paket: `1.0-SNAPSHOT` `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
```
Saat menggunakan contoh-contoh ini:
+ Ganti *my\$1domain* dengan nama CodeArtifact domain Anda.
+ Ganti *111122223333* dengan Akun AWS ID pemilik CodeArtifact domain Anda.
+ Ganti *us-west-2* Wilayah AWS dengan tempat CodeArtifact domain Anda berada.
+ Ganti *my\$1maven\$1repo* dengan nama CodeArtifact repositori Anda.
**penting**
Anda harus mengawali nilai `--data-binary` parameter dengan `@` karakter. Saat memasukkan nilai dalam tanda kutip, `@` harus disertakan di dalam tanda kutip.
Anda mungkin memiliki lebih dari dua aset untuk diunggah untuk setiap build. Misalnya, mungkin ada file Javadoc dan sumber JAR selain JAR utama dan. `pom.xml` Tidak perlu mempublikasikan file checksum untuk aset versi paket karena CodeArtifact secara otomatis menghasilkan checksum untuk setiap aset yang diunggah. Untuk memverifikasi aset telah diunggah dengan benar, ambil checksum yang dihasilkan menggunakan `list-package-version-assets` perintah dan bandingkan dengan checksum asli. Untuk informasi selengkapnya tentang cara CodeArtifact menangani checksum Maven, lihat. [Gunakan checksum Maven](maven-checksums.md)
Gunakan perintah curl berikut untuk memublikasikan `maven-metadata.xml` file untuk versi build terbaru:
```
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`File harus mereferensikan setidaknya satu aset dalam versi build terbaru dalam `` elemen. Selain itu, `` nilainya harus ada dan harus sesuai dengan stempel waktu dalam nama file aset. Misalnya, untuk `20210729.171330-2` build yang diterbitkan sebelumnya, isinya `maven-metadata.xml` adalah:
```
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`Setelah diterbitkan, langkah terakhir adalah mengatur semua versi build lainnya (yaitu, semua versi build terpisah dari build terbaru) agar memiliki status versi paket`Unlisted`. Misalnya, jika `1.0-SNAPSHOT` versi memiliki dua build, dengan build pertama`20210728.194552-1`, perintah untuk menyetel build tersebut `Unlisted` adalah:
```
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
```
## Snapshot dan koneksi eksternal
Snapshot Maven tidak dapat diambil dari repositori publik Maven melalui koneksi eksternal. AWS CodeArtifact hanya mendukung mengimpor versi rilis Maven.
## Snapshot dan repositori upstream
Secara umum, snapshot Maven bekerja dengan cara yang sama seperti versi rilis Maven saat digunakan dengan repositori upstream, tetapi ada batasan jika Anda berencana menerbitkan snapshot dari versi paket yang sama ke dua repositori yang memiliki hubungan hulu. Misalnya, katakan bahwa ada dua repositori dalam sebuah AWS CodeArtifact domain, `R` dan`U`, di mana `U` adalah hulu. `R` Jika Anda memublikasikan build baru`R`, saat klien Maven meminta build terbaru dari versi snapshot tersebut, CodeArtifact mengembalikan versi terbaru dari. `U` Ini bisa tidak terduga karena versi terbaru sekarang masuk`R`, tidak`U`. Ada dua cara untuk menghindari hal ini:
1. Jangan mempublikasikan build versi snapshot seperti `1.0-SNAPSHOT` in`R`, jika `1.0-SNAPSHOT` ada di. `U`
1. Gunakan kontrol asal CodeArtifact paket untuk menonaktifkan upstream pada paket itu di. `R` Yang terakhir akan memungkinkan Anda untuk mempublikasikan build `1.0-SNAPSHOT` in`R`, tetapi juga akan mencegah `R` versi lain dari paket itu dari `U` yang belum dipertahankan.
# Meminta paket Maven dari upstream dan koneksi eksternal
## Mengimpor nama aset standar
Saat mengimpor versi paket Maven dari repositori publik, seperti Maven Central, AWS CodeArtifact mencoba mengimpor semua aset dalam versi paket tersebut. Seperti dijelaskan dalam[Meminta versi paket dengan repositori hulu](repo-upstream-behavior.md), pengimporan terjadi ketika:
+ Klien meminta aset Maven dari repositori. CodeArtifact
+ Versi paket belum ada di repositori atau upstreams nya.
+ Ada koneksi eksternal yang dapat dijangkau ke repositori Maven publik.
Meskipun klien mungkin hanya meminta satu aset, CodeArtifact upaya untuk mengimpor semua aset yang dapat ditemukan untuk versi paket tersebut. Bagaimana CodeArtifact menemukan aset mana yang tersedia untuk versi paket Maven tergantung pada repositori publik tertentu. Beberapa repositori Maven publik mendukung permintaan daftar aset, tetapi yang lain tidak. Untuk repositori yang tidak menyediakan cara untuk membuat daftar aset, CodeArtifact menghasilkan satu set nama aset yang mungkin ada. Misalnya, ketika aset apa pun dari versi `junit 4.13.2` paket Maven diminta, CodeArtifact akan mencoba mengimpor aset berikut:
+ `junit-4.13.2.pom`
+ `junit-4.13.2.jar`
+ `junit-4.13.2-javadoc.jar`
+ `junit-4.13.2-sources.jar`
## Mengimpor nama aset non-standar
Ketika klien Maven meminta aset yang tidak cocok dengan salah satu pola yang dijelaskan di atas, CodeArtifact periksa untuk melihat apakah aset tersebut ada di repositori publik. Jika aset ada, itu akan diimpor dan ditambahkan ke catatan versi paket yang ada, jika ada. Misalnya, versi paket Maven `com.android.tools.build:aapt2 7.3.1-8691043` berisi aset berikut:
+ `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`
Ketika klien meminta file POM, jika CodeArtifact tidak dapat mencantumkan aset versi paket, POM akan menjadi satu-satunya aset yang diimpor. Ini karena tidak ada aset lain yang cocok dengan pola nama aset standar. Namun, ketika klien meminta salah satu aset JAR, aset tersebut akan diimpor dan ditambahkan ke versi paket yang ada yang disimpan di CodeArtifact. Versi paket di repositori paling hilir (repositori yang diminta klien) dan repositori dengan koneksi eksternal yang dilampirkan akan diperbarui untuk memuat aset baru, seperti yang dijelaskan dalam. [Retensi paket dari repositori hulu](repo-upstream-behavior.md#package-retention-upstream-repos)
Biasanya, setelah versi paket dipertahankan dalam CodeArtifact repositori, itu tidak terpengaruh oleh perubahan dalam repositori upstream. Untuk informasi selengkapnya, lihat [Retensi paket dari repositori hulu](repo-upstream-behavior.md#package-retention-upstream-repos). Namun, perilaku aset Maven dengan nama non-standar yang dijelaskan sebelumnya merupakan pengecualian untuk aturan ini. Meskipun versi paket hilir tidak akan berubah tanpa aset tambahan yang diminta oleh klien, dalam situasi ini, versi paket yang dipertahankan dimodifikasi setelah awalnya dipertahankan dan karenanya tidak dapat diubah. Perilaku ini diperlukan karena aset Maven dengan nama non-standar tidak akan dapat diakses melalui. CodeArtifact Perilaku ini juga memungkinkan jika ditambahkan ke versi paket Maven di repositori publik setelah versi paket dipertahankan dalam repositori. CodeArtifact
## Memeriksa asal-usul aset
Saat menambahkan aset baru ke versi paket Maven yang dipertahankan sebelumnya, CodeArtifact konfirmasikan asal versi paket yang ditahan sama dengan asal aset baru. Ini mencegah pembuatan versi paket “campuran” di mana aset yang berbeda berasal dari repositori publik yang berbeda. Tanpa pemeriksaan ini, pencampuran aset dapat terjadi jika versi paket Maven diterbitkan ke lebih dari satu repositori publik dan repositori tersebut adalah bagian dari grafik hulu repositori. CodeArtifact
## Mengimpor aset baru dan status versi paket di repositori hulu
[Status versi paket versi](packages-overview.md#package-version-status) paket di repositori hulu dapat CodeArtifact mencegah mempertahankan versi tersebut di repositori hilir.
Sebagai contoh, katakanlah sebuah domain memiliki tiga repositori:`repo-A`,, dan `repo-B``repo-C`, di mana `repo-B` adalah upsteam dari `repo-A` dan `repo-C` upstream dari. `repo-B`
![\[Diagram tentang cara kerja aset dan versi paket baru di repositori hulu.\]](http://docs.aws.amazon.com/id_id/codeartifact/latest/ug/images/Maven-new-asset-pv-upstream.png)
Package `7.3.1` versi paket Maven `com.android.tools.build:aapt2` hadir `repo-B` dan memiliki status. `Published` Itu tidak hadir di`repo-A`. Jika klien meminta aset versi paket ini dari`repo-A`, responsnya akan menjadi 200 (OK) dan versi paket Maven `7.3.1` akan dipertahankan. `repo-A` Namun, jika status versi paket `7.3.1` di `repo-B` adalah `Archived` atau`Disposed`, responsnya akan menjadi 404 (Tidak Ditemukan) karena aset versi paket di kedua status tersebut tidak dapat diunduh.
Perhatikan bahwa menyetel [kontrol asal paket](package-origin-controls.md) ke `upstream=BLOCK` for `com.android.tools.build:aapt2` in `repo-A``repo-B`,, dan `repo-C` akan mencegah aset baru diambil untuk semua versi paket tersebut`repo-A`, terlepas dari status versi paket.
# Pemecahan masalah Maven
Informasi berikut dapat membantu Anda memecahkan masalah umum dengan Maven dan. CodeArtifact
## Nonaktifkan parallel puts untuk memperbaiki kesalahan 429: Terlalu Banyak Permintaan
Dimulai dengan versi 3.9.0, Maven mengunggah artefak paket secara paralel (hingga 5 file sekaligus). Hal ini dapat CodeArtifact menyebabkan sesekali merespons dengan kode respons kesalahan 429 (Terlalu Banyak Permintaan). Jika Anda mengalami kesalahan ini, Anda dapat menonaktifkan parallel puts untuk memperbaikinya.
Untuk menonaktifkan parallel puts, atur `aether.connector.basic.parallelPut` properti ke `false` dalam profil Anda di `settings.xml` file Anda seperti yang ditunjukkan oleh contoh berikut:
```
default
false
```
Untuk informasi selengkapnya, lihat [Opsi Konfigurasi Resolver Artifact](https://maven.apache.org/resolver/configuration.html) di dokumentasi Maven.