

기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

# CodeArtifact를 Maven과 함께 사용
<a name="using-maven"></a>

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 사용
<a name="maven-gradle"></a>

[환경 변수를 사용하여 인증 토큰 전달](tokens-authentication.md#env-var)에 설명된 대로 CodeArtifact 인증 토큰을 환경 변수에 저장한 후, 다음 지침에 따라 CodeArtifact 리포지토리에서 Maven 패키지를 사용하고 새 패키지를 CodeArtifact 리포지토리에 게시합니다.

**Topics**
+ [종속성 가져오기](#fetching-dependencies)
+ [플러그인 가져오기](#fetching-plugins)
+ [아티팩트 게시](#publishing-artifacts)
+ [IntelliJ IDEA에서 Gradle 빌드 실행](#gradle-intellij)

## 종속성 가져오기
<a name="fetching-dependencies"></a>

Gradle 빌드의 CodeArtifact에서 종속 항목을 가져오려면 다음 절차를 사용하세요.

**Gradle 빌드의 CodeArtifact에서 종속 항목을 가져오려면**

1. CodeArtifact 인증 토큰을 아직 만들지 않았다면 [환경 변수를 사용하여 인증 토큰 전달](tokens-authentication.md#env-var)의 절차에 따라 이 인증 토큰을 만들어 환경 변수에 저장하세요.

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*이라는 도메인 내에 *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 리포지토리를 프로젝트 종속성의 유일한 소스로 사용하려면 `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'
   }
   ```

## 플러그인 가져오기
<a name="fetching-plugins"></a>

기본적으로 Gradle은 퍼블릭 [Gradle 플러그인 포털](https://plugins.gradle.org/)에서 플러그인을 확인합니다. CodeArtifact 리포지토리에서 플러그인을 가져오려면 다음 절차를 사용합니다.

**CodeArtifact 리포지토리에서 플러그인을 가져오려면**

1. CodeArtifact 인증 토큰을 아직 만들지 않았다면 [환경 변수를 사용하여 인증 토큰 전달](tokens-authentication.md#env-var)의 절차에 따라 이 인증 토큰을 만들어 환경 변수에 저장하세요.

1. `settings.gradle` 파일에 `pluginManagement` 블록을 추가합니다. `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 플러그인 포털(예: `gradle-plugins-store`)에 대한 외부 연결이 있는 업스트림 리포지토리가 있어야 합니다. 자세한 내용은 [Gradle 설명서](https://docs.gradle.org/current/userguide/plugins.html#sec:custom_plugin_repositories)를 참조하세요.

## 아티팩트 게시
<a name="publishing-artifacts"></a>

이 섹션에서는 Gradle로 빌드한 Java 라이브러리를 CodeArtifact 리포지토리에 게시하는 방법을 설명합니다.

먼저 프로젝트의 `build.gradle` 파일 중 `plugins` 섹션에 `maven-publish` 플러그인을 추가합니다.

```
plugins {
    id 'java-library'
    id 'maven-publish'
}
```

다음으로 프로젝트 `build.gradle` 파일에 `publishing` 섹션을 추가합니다.

```
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 빌드 실행
<a name="gradle-intellij"></a>

CodeArtifact에서 종속성을 가져오는 IntelliJ IDEA에서 Gradle 빌드를 실행할 수 있습니다. CodeArtifact로 인증하려면 Gradle에 CodeArtifact 인증 토큰을 제공해야 합니다. 인증 토큰을 제공하는 방법은 세 가지가 있습니다.
+ 방법 1: 인증 토큰을 `gradle.properties`에 저장. `gradle.properties` 파일의 내용을 덮어쓰거나 추가할 수 있는 경우, 이 방법을 사용합니다.
+ 방법 2: 인증 토큰을 별도의 파일에 저장. `gradle.properties` 파일을 수정하지 않으려면 이 방법을 사용하세요.
+ 방법 3: `build.gradle`에서 `aws`를 인라인 스크립트로 실행하여 실행할 때마다 새 인증 토큰을 생성. 실행할 때마다 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: `build.gradle`에서 `aws`를 인라인 스크립트로 실행하여 실행할 때마다 새 인증 토큰을 생성**

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 사용
<a name="maven-mvn"></a>

`mvn` 명령을 사용하여 Maven 빌드를 실행합니다. 이 섹션에서는 CodeArtifact 리포지토리를 사용하도록 `mvn`을 구성하는 방법에 대해 설명합니다.

**Topics**
+ [종속성 가져오기](#fetching-dependencies)
+ [아티팩트 게시](#publishing-artifacts)
+ [타사 아티팩트 게시](#publishing-third-party-artifacts)
+ [CodeArtifact 리포지토리에서만 Maven 종속성을 다운로드](#restrict-maven-downloads)
+ [Apache Maven 프로젝트 정보](#apache-maven-project-info)

## 종속성 가져오기
<a name="fetching-dependencies"></a>

CodeArtifact 리포지토리에서 종속성을 가져오도록 `mvn`을 구성하려면 Maven 구성 파일, `settings.xml` 및 프로젝트의 POM(선택 사항)을 편집해야 합니다.

1. 아직 생성 및 저장을 하지 않았다면 CodeArtifact 리포지토리에 대한 인증을 설정하기 위해 [환경 변수를 사용하여 인증 토큰 전달](tokens-authentication.md#env-var)에 설명된 대로 환경 변수에 CodeArtifact 인증 토큰을 만들고 저장하십시오.

1. Maven이 HTTP 요청에서 토큰을 전달하도록 `settings.xml`(대체로 `~/.m2/settings.xml`에서 볼 수 있음)에서 `CODEARTIFACT_AUTH_TOKEN` 환경 변수에 대한 참조가 있는 `<servers>` 섹션을 추가합니다.

   ```
   <settings>
   ...
       <servers>
           <server>
               <id>codeartifact</id>
               <username>aws</username>
               <password>${env.CODEARTIFACT_AUTH_TOKEN}</password>
           </server>
       </servers>
   ...
   </settings>
   ```

1. `<repository>` 요소에서 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`에 추가합니다.

   ```
   <settings>
   ...
       <profiles>
           <profile>
               <id>default</id>
               <repositories>
                   <repository>
                       <id>codeartifact</id>
                       <url>https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/</url>
                   </repository>
               </repositories>
           </profile>
       </profiles>
       <activeProfiles>
           <activeProfile>default</activeProfile>
       </activeProfiles>
       ...
   </settings>
   ```

   또는 `<repositories>` 섹션을 프로젝트 POM 파일에 추가하여 해당 프로젝트에만 CodeArtifact를 사용할 수 있습니다.

   ```
   <project>
   ...
       <repositories>
           <repository>
               <id>codeartifact</id>
               <name>codeartifact</name>
               <url>https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/</url>
           </repository>
       </repositories>
   ...
   </project>
   ```

**중요**  
`<id>` 요소에서 어떤 값이든 사용할 수 있지만 그 값은 `<server>` 및 `<repository>` 요소에서 모두 동일해야 합니다. 이렇게 하면 지정된 보안 인증을 CodeArtifact에 대한 요청에 포함할 수 있습니다.

이러한 구성을 변경한 후 프로젝트를 빌드할 수 있습니다.

```
mvn compile
```

Maven은 콘솔에 다운로드한 모든 종속성의 전체 URL을 기록합니다.

```
[INFO] ------------------< com.example.example:myapp >-------------------
[INFO] Building myapp 1.0
[INFO] --------------------------------[ jar ]---------------------------------
Downloading from codeartifact: https://<domain>.d.codeartifact.us-west-2.amazonaws.com/maven/myrepo/commons-cli/commons-cli/1.4/commons-cli-1.4.pom
Downloaded from codeartifact: https://<domain>.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://<domain>.d.codeartifact.us-west-2.amazonaws.com/maven/myrepo/org/apache/commons/commons-parent/42/commons-parent-42.pom
Downloading from codeartifact: https://<domain>.d.codeartifact.us-west-2.amazonaws.com/maven/myrepo/org/apache/commons/commons-parent/42/commons-parent-42.pom
Downloaded from codeartifact: https://<domain>.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://<domain>.d.codeartifact.us-west-2.amazonaws.com/maven/myrepo/commons-cli/commons-cli/1.4/commons-cli-1.4.jar
Downloaded from codeartifact: https://<domain>.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)
```

## 아티팩트 게시
<a name="publishing-artifacts"></a>

`mvn`과 함께 Maven 아티팩트를 CodeArtifact 리포지토리에 게시하려면 `~/.m2/settings.xml` 및 프로젝트 POM도 편집해야 합니다.

1. 아직 생성 및 저장을 하지 않았다면 CodeArtifact 리포지토리에 대한 인증을 설정하기 위해 [환경 변수를 사용하여 인증 토큰 전달](tokens-authentication.md#env-var)에 설명된 대로 환경 변수에 CodeArtifact 인증 토큰을 만들고 저장하십시오.

1. Maven이 HTTP 요청에서 토큰을 전달하도록 `<servers>` 섹션을 `CODEARTIFACT_AUTH_TOKEN` 환경 변수에 대한 참조가 있는 `settings.xml`에 추가합니다.

   ```
   <settings>
   ...
       <servers>
           <server>
               <id>codeartifact</id>
               <username>aws</username>
               <password>${env.CODEARTIFACT_AUTH_TOKEN}</password>
           </server>
       </servers>
   ...
   </settings>
   ```

1. 프로젝트의 `pom.xml`에 `<distributionManagement>` 섹션을 추가합니다.

   ```
   <project>
   ...
        <distributionManagement>
            <repository>
                <id>codeartifact</id>
                <name>codeartifact</name>
                <url>https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/</url>
            </repository>
        </distributionManagement>
   ...
   </project>
   ```

이러한 구성을 변경한 후 프로젝트를 빌드하여 지정된 리포지토리에 게시할 수 있습니다.

```
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"
        }
    ]
}
```

## 타사 아티팩트 게시
<a name="publishing-third-party-artifacts"></a>

`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` 파일을 생성합니다.

   ```
   <settings>
       <servers>
           <server>
               <id>codeartifact</id>
               <username>aws</username>
               <password>${env.CODEARTIFACT_AUTH_TOKEN}</password>
           </server>
       </servers>
   </settings>
   ```

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 설명서의 [타사 JAR을 원격 리포지토리에 배포하기 위한 가이드](https://maven.apache.org/guides/mini/guide-3rd-party-jars-remote.html)의 예제를 기반으로 합니다.

## CodeArtifact 리포지토리에서만 Maven 종속성을 다운로드
<a name="restrict-maven-downloads"></a>

 구성된 리포지토리에서 패키지를 가져올 수 없는 경우, 기본적으로 `mvn` 명령을 실행하면 Maven Central에서 패키지를 가져옵니다. `mvn`이 CodeArtifact 리포지토리를 항상 사용할 수 있도록 `mirrors` 요소를 `settings.xml`에 추가합니다.

```
<settings>
  ...
    <mirrors>
      <mirror>
        <id>central-mirror</id>
        <name>CodeArtifact Maven Central mirror</name>
        <url>https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/</url>
        <mirrorOf>central</mirrorOf>
      </mirror>
    </mirrors>
  ...
</settings>
```

`mirrors` 요소를 추가하는 경우 `settings.xml` 또는 `pom.xml`에도 `pluginRepository` 요소가 있어야 합니다. 다음 예제는 CodeArtifact 리포지토리에서 애플리케이션 종속성과 Maven 플러그인을 가져옵니다.

```
<settings>
...
  <profiles>
    <profile>
      <pluginRepositories>
        <pluginRepository>
          <id>codeartifact</id>
          <name>CodeArtifact Plugins</name>
          <url>https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/</url>
          <releases>
            <enabled>true</enabled>
          </releases>
          <snapshots>
            <enabled>true</enabled>
          </snapshots>
        </pluginRepository>
      </pluginRepositories>
    </profile>
  </profiles>
...
</settings>
```

다음 예제는 CodeArtifact 리포지토리에서 애플리케이션 종속성을 가져오며 Maven Central에서 Maven 플러그인을 가져옵니다.

```
<profiles>
   <profile>
     <id>default</id>
     ...
     <pluginRepositories>
       <pluginRepository>
         <id>central-plugins</id>
         <name>Central Plugins</name>
         <url>https://repo.maven.apache.org/maven2/</url>
         <releases>
             <enabled>true</enabled>
         </releases>
         <snapshots>
             <enabled>true</enabled>
         </snapshots>
       </pluginRepository>
     </pluginRepositories>
   ....
   </profile>
 </profiles>
```

## Apache Maven 프로젝트 정보
<a name="apache-maven-project-info"></a>

Maven에 관한 자세한 내용은 Apache Maven Project 웹 사이트에서 다음 주제를 참조하세요.
+  [여러 리포지토리 설정](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과 함께 사용
<a name="maven-deps"></a>

`deps.edn`을 `clj`와 함께 사용하여 Clojure 프로젝트의 종속성을 관리할 수 있습니다. 이 섹션에서는 CodeArtifact 리포지토리를 사용하도록 `deps.edn`을 구성하는 방법에 대해 설명합니다.

**Topics**
+ [종속성 가져오기](#fetching-dependencies-deps)
+ [아티팩트 게시](#publishing-artifacts-deps)

## 종속성 가져오기
<a name="fetching-dependencies-deps"></a>

CodeArtifact 리포지토리에서 종속성을 가져오도록 `Clojure`를 구성하려면 Maven 구성 파일 `settings.xml`을 편집해야 합니다.

1. Clojure가 HTTP 요청에서 토큰을 전달하도록 `settings.xml`에서 `CODEARTIFACT_AUTH_TOKEN` 환경 변수에 대한 참조가 있는 `<servers>` 섹션을 추가합니다.
**참고**  
Clojure는 settings.xml 파일이 `~/.m2/settings.xml`에 있을 것으로 예상합니다. 다른 곳에 있다면 이 위치에 파일을 생성하세요.

   ```
   <settings>
   ...
       <servers>
           <server>
               <id>codeartifact</id>
               <username>aws</username>
               <password>${env.CODEARTIFACT_AUTH_TOKEN}</password>
           </server>
       </servers>
   ...
   </settings>
   ```

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/"}
   }
   ```
**참고**  
`tools.deps`를 실행하면 `central` 및 `clojars` 리포지토리에서 Maven 라이브러리를 먼저 확인하게 됩니다. 그런 다음, `deps.edn`에 나열된 다른 리포지토리도 검사됩니다.
Clojars와 Maven Central에서 직접 다운로드하는 것을 방지하려면 `central`과 `clojars`를 `nil`로 설정해야 합니다.

   환경 변수에 CodeArtifact 인증 토큰이 있는지 확인합니다([환경 변수를 사용하여 인증 토큰 전달](tokens-authentication.md#env-var) 참조). 이러한 변경 후 패키지를 빌드하면 CodeArtifact에서 `deps.edn`의 종속성을 가져옵니다.
**참고**  
듀얼 스택 엔드포인트를 사용하려면 `codeartifact.region.on.aws` 엔드포인트를 사용합니다.

## 아티팩트 게시
<a name="publishing-artifacts-deps"></a>

1. CodeArtifact를 Maven이 인식하는 서버로 포함하도록 Maven 설정과 `deps.edn`을 업데이트합니다([종속성 가져오기](#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 및 CLI 참조 근거에서 [기본 리포지토리 수정](https://clojure.org/reference/deps_and_cli#_modifying_the_default_repositories)을 참조합니다.

# curl을 사용한 게시
<a name="maven-curl"></a>

이 섹션에서는 HTTP 클라이언트 `curl`을 사용하여 CodeArtifact 리포지토리에 Maven 아티팩트를 게시하는 방법을 보여줍니다. 환경에 Maven 클라이언트가 없거나 이 클라이언트를 설치하려는 경우, `curl`을 사용하여 아티팩트를 게시하는 것이 도움이 될 수 있습니다.

**`curl`을 사용하여 Maven 아티팩트를 게시**

1. [환경 변수를 사용하여 인증 토큰 전달](tokens-authentication.md#env-var)의 단계에 따라 CodeArtifact 인증 토큰을 가져오고 이 단계로 돌아갑니다.

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 아티팩트는 상태가 `Unfinished`인 CodeArtifact 리포지토리에 저장됩니다. 패키지를 사용하려면 패키지가 `Published` 상태에 있어야 합니다. 패키지에 `maven-metadata.xml` 파일을 업로드하거나 [UpdatePackageVersionsStatus API](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html)를 직접적으로 호출하여 상태를 변경함으로써 패키지를 `Unfinished`에서 `Published`로 이동할 수 있습니다.

   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` 파일의 내용을 보여주는 예제입니다.

      ```
      <metadata modelVersion="1.1.0">
          <groupId>com.mycompany.app</groupId>
          <artifactId>my-app</artifactId>
          <versioning>
              <latest>1.0</latest>
              <release>1.0</release>
              <versions>
                  <version>1.0</version>
              </versions>
              <lastUpdated>20200731090423</lastUpdated>
          </versioning>
      </metadata>
      ```

   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
      ```

아티팩트의 JAR 파일만 있는 경우 `mvn`을 사용하여 CodeArtifact 리포지토리에 사용 가능한 패키지 버전을 게시할 수 있습니다. 이는 아티팩트의 소스 코드나 POM에 액세스할 수 없는 경우에 도움이 될 수 있습니다. 세부 정보는 [타사 아티팩트 게시](maven-mvn.md#publishing-third-party-artifacts) 섹션을 참조하세요.

# Maven 체크섬 사용
<a name="maven-checksums"></a>

 Maven 아티팩트가 an AWS CodeArtifact 리포지토리에 게시되면 패키지의 각 *자산* 또는 파일과 연결된 체크섬이 업로드를 검증하는 데 사용됩니다. 자산의 예로는 **jar, **pom, **war 파일 등이 있습니다. 각 자산의 경우, `md5` 또는 `sha1` 같은 추가 확장자가 있는 자산 이름을 사용하는 여러 개의 체크섬 파일이 Maven 아티팩트에 포함되어 있습니다. 예를 들어, `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)를 참조하세요.

## 체크섬 스토리지
<a name="maven-checksum-storage"></a>

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
```

`curl`과 같은 일반 HTTP 클라이언트를 사용하여 기존 Maven 패키지(예: 이전에 Amazon S3에 저장된 패키지)를 CodeArtifact에 업로드하는 경우, 체크섬을 업로드할 필요가 없습니다. CodeArtifact는 체크섬을 자동으로 생성합니다. 자산이 올바르게 업로드되었는지 확인하려는 경우, ListPackageVersionAssets API 작업을 사용하여 각 자산의 원래 체크섬 값에 대한 응답의 체크섬을 비교할 수 있습니다.

## 게시 중 체크섬 불일치
<a name="maven-checksum-mismatch"></a>

자산과 체크섬 외에도 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`로 계속 유지되기 때문입니다.

CodeArtifact를 사용하면 `maven-metadata.xml`이 업로드되고 패키지 버전 상태가 `Published`로 설정된 후에도 Maven 패키지 버전에 자산을 더 추가할 수 있습니다. 이 상태에서는 불일치한 체크섬 파일을 업로드하라는 요청도 실패하며 **400(잘못된 요청)** 응답이 함께 표시됩니다. 하지만 패키지 버전 상태가 이미 `Published`로 설정되었으므로 체크섬 파일 업로드가 실패한 자산을 포함하여 패키지에서 모든 자산을 다운로드할 수 있습니다. 체크섬 파일 업로드가 실패한 자산의 체크섬을 다운로드할 때 클라이언트가 수신하는 체크섬 값은 업로드된 자산 데이터를 기반으로 CodeArtifact에서 계산한 체크섬 값입니다.

CodeArtifact 체크섬 비교는 대소문자를 구분하며 CodeArtifact로 계산된 체크섬은 소문자 형식으로 표시됩니다. 따라서 `909FA780F76DA393E992A3D2D495F468` 체크섬이 업로드되면 CodeArtifact가 이를 `909fa780f76da393e992a3d2d495f468`과 같은 것으로 처리하지 않기 때문에 체크섬 불일치로 실패합니다.

## 체크섬 불일치 복구하기
<a name="maven-checksum-mismatch-recovery"></a>

체크섬 불일치로 인해 체크섬 업로드가 실패하는 경우, 다음 중 하나를 시도하여 복구합니다.
+ Maven 아티팩트를 다시 게시하는 명령을 실행합니다. 네트워크 문제로 인해 체크섬 파일이 손상된 경우, 이러한 명령 실행이 효과적일 수 있습니다. 이러한 방법으로 네트워크 문제가 해결되면 체크섬이 일치하여 다운로드가 완료됩니다.
+ 패키지 버전을 삭제한 후 다시 게시합니다. 자세한 내용은 **AWS CodeArtifact API 참조의 [DeletePackageVersions](https://docs.aws.amazon.com/dms/latest/APIReference/API_DeletePackageVersions.html)를 참조하세요.

# Maven 스냅샷 사용
<a name="maven-snapshots"></a>

 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에서의 스냅샷 게시
<a name="maven-snapshot-publishing"></a>

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`이 있지만 두 버전 모두 동일한 자산을 포함하고 있습니다.

```
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` 파일을 업로드하는 것으로 시작됩니다.

## 스냅샷 버전 사용
<a name="maven-consuming-snapshot-versions"></a>

스냅샷을 요청하면 상태 `Published`의 버전이 반환됩니다. 이 버전은 항상 Maven 스냅샷의 최신 버전입니다. URL 경로의 스냅샷 버전(예: `1.0-SNAPSHOT`) 대신 빌드 버전 번호(예: `1.0-20210728.194552-1`)를 사용하여 스냅샷의 특정 빌드를 요청할 수도 있습니다. Maven 스냅샷의 빌드 버전을 보려면 **CodeArtifact API 안내서의 [ListPackageVersions ](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersions.html) API를 사용하고 상태 파라미터를 `Unlisted`로 설정합니다.

## 스냅샷 버전 삭제
<a name="maven-deleting-snapshot-versions"></a>

Maven 스냅샷의 모든 빌드 버전을 삭제하려면 [DeletePackageVersions](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_DeletePackageVersions.html) API를 사용하여 삭제하려는 버전을 지정합니다.

## curl을 사용한 스냅샷 게시
<a name="maven-snapshot-publishing-curl"></a>

Amazon Simple Storage Service(Amazon S3) 또는 다른 아티팩트 리포지토리 제품에 저장된 기존 스냅샷 버전이 있는 경우 이를 AWS CodeArtifact에 다시 게시할 수 있습니다. CodeArtifact가 Maven 스냅샷을 지원하는 방식 때문에([CodeArtifact에서의 스냅샷 게시](#maven-snapshot-publishing) 참조) 일반 HTTP 클라이언트(예: `curl`)를 사용하여 스냅샷을 게시하는 것은 [curl을 사용한 게시](maven-curl.md)에 설명된 대로 Maven 릴리스 버전을 게시하는 것보다 더 복잡합니다. `mvn` 또는 `gradle` 같은 Maven 클라이언트를 사용하여 스냅샷 버전을 빌드하고 배포하는 경우, 이 섹션은 관련성이 없습니다. Maven 클라이언트에 대한 설명서를 따라야 합니다.

스냅샷 버전을 게시하려면 스냅샷 버전의 빌드를 하나 이상 게시해야 합니다. CodeArtifact에서 스냅샷 버전의 빌드가 **n개 이상 있는 경우, CodeArtifact 버전이 **n\$11개 즉, 상태가 `Unlisted`인 빌드 버전이 **n개, 상태가 `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` 파라미터의 값 앞에 문자 `@`을 붙여야 합니다. 값을 따옴표로 묶을 때는 따옴표 안에 `@`을 포함해야 합니다.

각 빌드에 업로드할 자산이 두 개 이상 존재할 수 있습니다. 예를 들어, 기본 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` 파일은 `<snapshotVersions>` 요소의 최신 빌드 버전에 있는 자산 중 한 가지 이상을 참조해야 합니다. 또한 `<timestamp>` 값이 있어야 하며 이 값은 자산 파일 이름의 타임스탬프와 일치해야 합니다. 예를 들어, 이전에 게시된 `20210729.171330-2` 빌드의 경우 `maven-metadata.xml`의 내용은 다음과 같습니다.

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

`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
```

## 스냅샷과 외부 연결
<a name="maven-snapshot-external-connections"></a>

Maven 스냅샷은 외부 연결을 통해 Maven 퍼블릭 리포지토리에서 가져올 수 없습니다. AWS CodeArtifact는 Maven 릴리스 버전 가져오기만 지원합니다.

## 스냅샷 및 업스트림 리포지토리
<a name="maven-snapshot-upstream-repositories"></a>

일반적으로 Maven 스냅샷은 업스트림 리포지토리와 함께 사용할 때 Maven 릴리스 버전과 동일한 방식으로 작동하지만, 업스트림 관계가 있는 두 리포지토리에 동일한 패키지 버전의 스냅샷을 게시하려는 경우 제한이 있습니다. 예를 들어 an AWS CodeArtifact 도메인에 리포지토리가 두 개 `R` 있고`U`, 여기서 `U`는의 업스트림입니다`R`. `R`에 새 빌드를 게시하는 경우 Maven 클라이언트가 해당 스냅샷 버전의 최신 빌드를 요청하면 CodeArtifact는 `U`에서 최신 버전을 반환합니다. 이제 최신 버전이 `U`가 아닌 `R`에 있기 때문에 이로 인해 예기치 않은 상황이 발생할 수 있습니다. 이를 피하는 방법은 두 가지입니다.

1. `U`에 `1.0-SNAPSHOT`이 있는 경우 `R`의 `1.0-SNAPSHOT`과 같은 스냅샷 버전의 빌드를 게시하지 마십시오.

1. CodeArtifact 패키지 원본 제어를 사용하여 `R`에서 해당 패키지의 업스트림을 비활성화합니다. 후자는 `R`에서 `1.0-SNAPSHOT`의 빌드를 게시하도록 허용하지만 `R`이 아직 보존되지 않은 `U`에서 해당 패키지의 다른 버전을 가져오지 못하게 합니다.

# 업스트림 및 외부 연결에서 Maven 패키지 요청
<a name="maven-upstream-external-connections-request"></a>



## 표준 자산 이름 가져오기
<a name="maven-import-standard-asset-names"></a>

Maven Central과 같은 퍼블릭 리포지토리에서 Maven 패키지 버전을 가져올 때 AWS CodeArtifact는 해당 패키지 버전의 모든 자산을 가져오려고 시도합니다. [업스트림 리포지토리가 포함된 패키지 버전 요청](repo-upstream-behavior.md)에 설명된 대로 다음과 같은 경우에 가져오기가 실행됩니다.
+ 클라이언트는 CodeArtifact 리포지토리에서 Maven 자산을 요청합니다.
+ 패키지 버전은 리포지토리 또는 해당 업스트림에 아직 없습니다.
+ 퍼블릭 Maven 리포지토리에 연결할 수 있는 외부 연결이 있습니다.

클라이언트가 하나의 자산만 요청했더라도 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`

## 비표준 자산 이름 가져오기
<a name="maven-import-nonstandard-asset-names"></a>

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 자산의 동작은 이 규칙의 예외에 속합니다. 클라이언트가 추가 자산을 요청하지 않으면 다운스트림 패키지 버전이 변경되지 않지만 이 경우 보존된 패키지 버전은 맨 처음 보존된 후에 수정되므로 변경 불가능하지 않습니다. 그렇지 않으면 CodeArtifact를 통해 비표준 이름을 가진 Maven 자산에 액세스할 수 없기 때문에 이 동작이 필요합니다. 이 동작은 패키지 버전이 CodeArtifact 리포지토리에 보존된 후 퍼블릭 리포지토리의 Maven 패키지 버전에 추가된 경우에도 활성화됩니다.

## 자산 출처 확인
<a name="origin-checks-for-assets"></a>

이전에 보존된 Maven 패키지 버전에 새 자산을 추가할 때 CodeArtifact는 보존된 패키지 버전의 원본이 새 자산의 원본과 동일한지 확인합니다. 이렇게 하면 서로 다른 퍼블릭 리포지토리에서 여러 자산이 생성되는 ‘혼합’ 패키지 버전을 만들 수 없습니다. 이 검사를 하지 않으면 Maven 패키지 버전이 둘 이상의 퍼블릭 리포지토리에 게시되고 해당 리포지토리가 CodeArtifact 리포지토리의 업스트림 그래프에 속하는 경우 자산 혼합이 발생할 수 있습니다.

## 업스트림 리포지토리에서 새 자산 가져오기 및 패키지 버전 상태
<a name="new-asset-importing-pv-status-upstream-repos"></a>

업스트림 리포지토리에 있는 패키지 버전의 [패키지 버전 상태](packages-overview.md#package-version-status)로 인해 CodeArtifact가 다운스트림 리포지토리에 해당 버전을 보존하지 못할 수 있습니다.

예를 들어, 하나의 도메인에 세 개의 리포지토리 즉, `repo-A`, `repo-B`, `repo-C`가 있는데 여기서 `repo-B`는 `repo-A`의 업스트림이고 `repo-C`는 `repo-B`의 업스트림이라고 가정해 보겠습니다.

![\[업스트림 리포지토리에서 새 자산 및 패키지 버전이 작동하는 방식을 보여주는 다이어그램입니다.\]](http://docs.aws.amazon.com/ko_kr/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`인 경우, 404(찾을 수 없음)라는 응답이 표시됩니다. 이 두 상태에서 패키지 버전의 자산은 다운로드할 수 없기 때문입니다.

`repo-A`, `repo-B` 및 `repo-C`에서 `com.android.tools.build:aapt2`에 대한 [패키지 오리진 제어](package-origin-controls.md)를 `upstream=BLOCK`로 설정하면 패키지 버전 상태와 관계없이 `repo-A`에서 해당 패키지의 모든 버전에 대한 새 자산을 가져오지 못하게 됩니다.

# Maven 문제 해결
<a name="maven-troubleshooting"></a>

다음은 Maven을 CodeArtifact와 함께 사용할 때 일반적으로 발생하는 문제를 해결하는 데 유용한 정보입니다.

## 병렬 입력을 비활성화하여 오류 429 수정: 요청이 너무 많음
<a name="disable-parallel-puts"></a>

버전 3.9.0부터 Maven은 패키지 아티팩트를 병렬로 업로드합니다(한 번에 최대 5개 파일). 이로 인해 CodeArtifact가 오류 응답 코드 429(요청이 너무 많음)로 응답하는 경우가 있을 수 있습니다. 이 오류가 발생한 경우 병렬 입력을 비활성화하여 수정할 수 있습니다.

병렬 입력을 비활성화하려면 다음 예와 같이 `settings.xml` 파일의 프로필에서 `aether.connector.basic.parallelPut` 속성을 `false`로 설정합니다.

```
<settings>
    <profiles>
        <profile>
            <id>default</id>
            <properties>
                <aether.connector.basic.parallelPut>false</aether.connector.basic.parallelPut>
            </properties>
        </profile>
    </profiles>
<settings>
```

자세한 내용은 Maven 설명서의 [아티팩트 해석기 구성 옵션](https://maven.apache.org/resolver/configuration.html)을 참조하세요.