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

# CodePipeline 자습서
<a name="tutorials"></a>

의 단계를 완료한 후이 사용 설명서의 AWS CodePipeline 자습서 중 하나를 사용해 [CodePipeline 시작하기](getting-started-codepipeline.md)볼 수 있습니다.

**Topics**
+ [자습서: CodePipeline을 사용하여 Amazon EC2 인스턴스에 배포](tutorials-ec2-deploy.md)
+ [자습서: CodePipeline을 사용하여 Docker 이미지를 빌드하고 Amazon ECR에 푸시(V2 유형)](tutorials-ecr-build-publish.md)
+ [자습서: CodePipeline을 사용하여 Amazon EKS에 배포](tutorials-eks-deploy.md)
+ [자습서: 컴퓨팅으로 명령을 실행하는 파이프라인 생성(V2 유형)](tutorials-commands.md)
+ [자습서: Git 태그를 사용하여 파이프라인 시작하기](tutorials-github-tags.md)
+ [자습서: 파이프라인을 시작하기 위한 풀 요청의 브랜치 이름 필터링(V2 유형)](tutorials-github-featurebranches.md)
+ [자습서: 파이프라인 수준 변수 사용](tutorials-pipeline-variables.md)
+ [자습서: 간단한 파이프라인 생성(S3 버킷)](tutorials-simple-s3.md)
+ [자습서: 간단한 파이프라인 생성(CodeCommit 리포지토리)](tutorials-simple-codecommit.md)
+ [자습서: 4단계 파이프라인 생성](tutorials-four-stage-pipeline.md)
+ [자습서: 파이프라인 상태 변경에 대한 이메일 알림을 수신하도록 CloudWatch Events 규칙 설정](tutorials-cloudwatch-sns-notifications.md)
+ [자습서:를 사용하여 Android 앱을 빌드하고 테스트하는 파이프라인 생성 AWS Device Farm](tutorials-codebuild-devicefarm.md)
+ [자습서:를 사용하여 iOS 앱을 테스트하는 파이프라인 생성 AWS Device Farm](tutorials-codebuild-devicefarm-S3.md)
+ [자습서: Service Catalog에 배포하는 파이프라인 생성](tutorials-S3-servicecatalog.md)
+ [자습서:를 사용하여 파이프라인 생성 AWS CloudFormation](tutorials-cloudformation.md)
+ [자습서: AWS CloudFormation 배포 작업의 변수를 사용하는 파이프라인 생성](tutorials-cloudformation-action.md)
+ [자습서: CodePipeline을 사용한 Amazon ECS 표준 배포](ecs-cd-pipeline.md)
+ [자습서: Amazon ECR 소스 및 ECS-to-CodeDeploy 배포를 사용하여 파이프라인 생성](tutorials-ecs-ecr-codedeploy.md)
+ [자습서: Amazon Alexa Skill을 배포하는 파이프라인 생성](tutorials-alexa-skills-kit.md)
+ [자습서: Amazon S3를 배포 공급자로 사용하는 파이프라인 생성](tutorials-s3deploy.md)
+ [자습서: 서버리스 애플리케이션을에 게시하는 파이프라인 생성 AWS Serverless Application Repository](tutorials-serverlessrepo-auto-publish.md)
+ [자습서: CodePipeline을 사용한 Lambda 함수 배포](tutorials-lambda-deploy.md)
+ [자습서: Lambda 호출 작업과 함께 변수 사용](tutorials-lambda-variables.md)
+ [자습서: 파이프라인에서 AWS Step Functions 호출 작업 사용](tutorials-step-functions.md)
+ [자습서: AWS AppConfig를 배포 공급자로 사용하는 파이프라인 생성](tutorials-AppConfig.md)
+ [자습서: GitHub 파이프라인 소스와 함께 전체 복제 사용](tutorials-github-gitclone.md)
+ [자습서: CodeCommit 파이프라인 소스와 함께 전체 복제 사용](tutorials-codecommit-gitclone.md)
+ [자습서: AWS CloudFormation StackSets 배포 작업을 사용하여 파이프라인 생성](tutorials-stackset-deployment.md)
+ [자습서: 입력 조건으로 파이프라인에 대한 변수 확인 규칙 생성](tutorials-varcheckrule.md)

# 자습서: CodePipeline을 사용하여 Amazon EC2 인스턴스에 배포
<a name="tutorials-ec2-deploy"></a>

이 자습서는 CodePipeline에서 Amazon EC2에서 구성한 인스턴스에 코드를 배포하는 배포 작업을 생성하는 데 도움이 됩니다.

**참고**  
콘솔에서 파이프라인을 생성하는 과정에서 CodePipeline은 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

**참고**  
`EC2` 배포 작업은 V2 유형 파이프라인에서만 사용할 수 있습니다.

## 사전 조건
<a name="tutorials-ec2-deploy-prereqs"></a>

이 자습서를 이용하여 CD 파이프라인을 만들려면 먼저 몇 가지 리소스를 갖춰야 합니다. 다음은 시작하기 위해 필요한 항목입니다.

**참고**  
이러한 모든 리소스는 동일한 AWS 리전 내에 생성되어야 합니다.
+ 샘플 `script.sh` 파일을 추가할 소스 제어 리포지토리(이 자습서에서는 GitHub 사용).
+ 이 작업에 대한 권한으로 업데이트된 기존 CodePipeline 서비스 역할을 사용해야 합니다. 서비스 역할을 업데이트하려면 [EC2 배포 작업에 대한 서비스 역할 정책 권한](action-reference-EC2Deploy.md#action-reference-EC2Deploy-permissions-action) 섹션을 참조하세요.

이러한 사전 조건을 모두 갖췄으면 이제 자습서를 이용하여 CD 파이프라인을 만들 수 있습니다.

## 1단계: Amazon EC2 Linux 인스턴스 생성
<a name="tutorials-ec2-deploy-instances"></a>

이 단계에서는 샘플 애플리케이션이 배포되는 Amazon EC2 인스턴스를 생성합니다. 리소스를 생성하려는 리전에서 인스턴스 역할을 아직 생성하지 않은 경우 이 프로세스의 일부로 IAM에서 인스턴스 역할을 생성합니다.

**인스턴스 역할을 생성하려면**

1. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)에서 IAM 콘솔을 엽니다.

1. 콘솔 대시보드에서 **역할**을 선택합니다.

1. **역할 생성**을 선택합니다.

1. **신뢰할 수 있는 유형의 엔터티 선택**에서 **AWS 서비스**를 선택합니다. **사용 사례 선택**에서 **EC2**를 선택합니다. **Select your use case(사용 사례 선택)** 아래에서 **EC2**를 선택합니다. **다음**을 선택합니다.

1. 검색하여 **`AmazonSSMManagedEC2InstanceDefaultPolicy`**라는 정책을 선택합니다.

1. 검색하여 **`AmazonSSMManagedInstanceCore`**라는 정책을 선택합니다. **다음: 태그**를 선택합니다.

1. **다음: 검토**를 선택합니다. 역할의 이름을 입력합니다(예: **EC2InstanceRole**).
**참고**  
다음 단계를 위해 역할 이름을 적어 둡니다. 인스턴스를 생성할 때 이 역할을 선택합니다.
**참고**  
파이프라인 생성 후 파이프라인의 S3 아티팩트 버킷에 대한 액세스를 허용하는 권한을 이 역할에 추가합니다.

   **역할 생성**을 선택합니다.

**인스턴스를 시작하려면**

1. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)에서 Amazon EC2 콘솔을 엽니다.

1. 측면 탐색에서 **인스턴스**를 선택하고 페이지 상단에서 **인스턴스 시작**을 선택합니다.

1. **이름**에 **MyInstances**를 입력합니다. 그러면 인스턴스에 **Name**의 태그 **키**와 **MyInstances**의 태그 **값**이 할당됩니다.

1. **애플리케이션 및 OS 이미지(Amazon 머신 이미지)**에서 AWS 로고가 있는 **Amazon Linux** AMI 옵션을 찾아 선택했는지 확인합니다. (이 AMI는 Amazon Linux 2 AMI(HVM)로 기술되며 "프리 티어 가능"이라는 레이블이 지정되어 있습니다.)

1. **인스턴스 유형**에서 인스턴스의 하드웨어 구성으로 사용할 프리 티어 가능 `t2.micro` 유형을 선택합니다.

1. **키 페어(로그인)**에서 키 페어를 선택하거나 새로 생성합니다.

1. **네트워크 설정**에서 상태가 **활성화**인지 확인합니다.

1. **Advanced details**(고급 세부 정보)를 확장합니다. **IAM 인스턴스 프로파일**에서 이전 절차에서 생성한 IAM 역할을 선택합니다(예: **EC2InstanceRole**).
**참고**  
기본 역할을 생성하고 생성한 역할을 선택하지 않으므로 인스턴스 역할을 비워 두지 마세요.

1. **요약**에서 **인스턴스 수**에 `2`를 입력합니다.

1. **인스턴스 시작**을 선택합니다.

1. [**Instances**] 페이지에서 시작 상태를 볼 수 있습니다. 인스턴스를 시작할 때 초기 상태는 `pending`입니다. 인스턴스가 시작된 후에는 상태가 `running`으로 바뀌고 퍼블릭 DNS 이름을 받습니다. [**Public DNS**] 열이 표시되지 않으면 [**Show/Hide**] 아이콘을 선택하고 [**Public DNS**]를 선택합니다.

## 2단계: EC2 인스턴스 역할에 아티팩트 버킷 권한 추가
<a name="tutorials-ec2-deploy-role-s3"></a>

파이프라인의 아티팩트 버킷에 액세스할 수 있도록 인스턴스에 대해 생성한 EC2 인스턴스 역할을 업데이트해야 합니다.

**참고**  
인스턴스를 생성할 때 기존 EC2 인스턴스 역할을 생성하거나 사용합니다. `Access Denied` 오류를 방지하려면 인스턴스 역할에 S3 버킷 권한을 추가하여 인스턴스에 CodePipeline 아티팩트 버킷에 대한 권한을 부여해야 합니다. 파이프라인 리전의 아티팩트 버킷으로 범위가 지정된 `s3:GetObject` 권한으로 기본 역할을 생성하거나 기존 역할을 업데이트합니다.

1. CodePipeline 콘솔에서 파이프라인으로 이동합니다. **설정**을 선택합니다. 기존 파이프라인의 아티팩트 스토어 이름과 위치를 확인합니다. 아티팩트 버킷의 Amazon 리소스 이름(ARN)을 기록해 두고 복사합니다.

1. IAM 콘솔로 이동하여 **역할(Roles)**을 선택합니다. 이 자습서의 1단계에서 생성한 인스턴스 역할을 선택합니다.

1. **권한** 탭에서 **인라인 정책 추가(Add inline policy)**를 선택합니다.

1. 정책 문서에 다음 JSON을 추가하여 `Resource` 필드의 값을 버킷 ARN으로 바꿉니다.

   ```
   {
       "Effect": "Allow",
       "Principal": "*",
       "Action": "s3:GetObject",
       "Resource": "arn:aws:s3:::BucketName"
   }
   ```

1. **업데이트**를 선택합니다.

## 3단계: 리포지토리에 스크립트 파일 추가
<a name="tutorials-ec2-deploy-file"></a>

이 샘플 텍스트를 붙여넣어 배포의 스크립트 후 단계를 위한 `script.sh` 파일을 생성합니다.

```
echo "Hello World!" 
```

**`script.sh` 파일을 해당 소스 리포지토리에 추가하려면**

1. 텍스트 편집기를 연 후 위의 파일을 복사하여 새 파일에 붙여 넣습니다.

1. `script.sh` 파일을 커밋한 후 소스 리포지토리에 푸시합니다.

   1. 파일을 추가합니다.

      ```
      git add .
      ```

   1. 변경 내용을 커밋합니다.

      ```
      git commit -m "Adding script.sh."
      ```

   1. 커밋을 푸시합니다.

      ```
      git push
      ```

   리포지토리의 경로를 기록해 둡니다.

   ```
   /MyDemoRepo/test/script.sh
   ```

## 4단계: 파이프라인 생성
<a name="tutorials-ec2-deploy-pipeline"></a>

CodePipeline 마법사를 사용하여 파이프라인 스테이지를 생성하고, 소스 리포지토리를 연결합니다.

**파이프라인을 생성하려면**

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔을 엽니다.

1. [**Welcome**] 페이지, [**Getting started**] 페이지 또는 [**Pipelines**] 페이지에서 **Create pipeline(파이프라인 생성)**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 **MyPipeline**을 입력합니다.

1. CodePipeline은 특성과 가격이 다른 V1 및 V2 유형 파이프라인을 제공합니다. V2 유형은 콘솔에서 선택할 수 있는 유일한 유형입니다. 자세한 내용은 [파이프라인 유형](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)을 참조하세요. CodePipeline에 대한 요금 정보는 [요금](https://aws.amazon.com/codepipeline/pricing/)을 참조하세요.

1. **서비스 역할**에서 **기존 서비스 역할 사용**을 선택한 다음이 작업에 필요한 권한으로 업데이트된 CodePipeline 서비스 역할을 선택합니다. 이 작업에 대한 CodePipeline 서비스 역할을 구성하려면 [EC2 배포 작업에 대한 서비스 역할 정책 권한](action-reference-EC2Deploy.md#action-reference-EC2Deploy-permissions-action) 섹션을 참조하세요.

1. [**Advanced settings**]의 설정은 기본값 그대로 두고, [**Next**]를 선택합니다.

1. **3단계: 소스 스테이지 추가** 페이지에서 소스 스테이지를 추가합니다.

   1. **소스 공급자**에서 **GitHub(GitHub 앱 사용)**를 선택합니다.

   1. **연결**에서 기존 연결을 선택하거나 새로 생성합니다. GitHub 소스 작업에 대한 연결을 만들거나 관리하려면 [GitHub 연결](connections-github.md)을 참조하세요.

   1. **리포지토리 이름**에서 GitHub 리포지토리의 이름을 선택합니다.

   **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가** 페이지에서 **건너뛰기**를 선택합니다.

1. **5단계: 배포 스테이지 추가** 페이지에서 **EC2**를 선택합니다.  
![\[\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/ec2deploy-action.png)

   1. **대상 디렉터리**에 `/home/ec2-user/testhelloworld`와 같이 배포하려는 인스턴스의 디렉터리를 입력합니다.
**참고**  
인스턴스에서 작업을 사용할 배포 디렉터리를 지정합니다. 작업은 배포의 일부로 인스턴스에 지정된 디렉터리를 자동으로 생성합니다.

   1. **PostScript**에 `test/script.sh`와 같이 스크립트의 경로와 파일 이름을 입력합니다.

   1. **다음**을 선택합니다.

1. **6단계: 검토** 페이지에서 파이프라인 구성을 검토하고 **파이프라인 생성**을 선택하여 파이프라인을 생성합니다.  
![\[\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/ec2deploy-pipeline.png)

1. 파이프라인이 성공적으로 실행되면 **세부 정보 보기**를 선택하여 작업에 대한 로그를 보고 관리형 컴퓨팅 작업 출력을 확인합니다.  
![\[\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/ec2deploy-logs.png)  
![\[\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/ec2deploy-logs2.png)

## 5단계: 파이프라인 테스트
<a name="tutorials-ec2-deploy-test"></a>

파이프라인에는 end-to-end네이티브 AWS 지속적 배포를 실행하기 위한 모든 것이 있어야 합니다. 이제 소스 리포지토리에 코드 변경을 푸시하여 파이프라인 기능을 테스트해 보겠습니다.

**파이프라인을 테스트하려면**

1. 구성된 소스 리포지토리에 대한 코드를 변경하고 커밋한 후 변경 사항을 푸시합니다.

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔을 엽니다.

1. 목록에서 파이프라인을 선택합니다.

1. 단계를 수행하면서 파이프라인 진행 상황을 관찰합니다. 파이프라인이 완료되고 작업이 인스턴스에 스크립트를 배포합니다.

1. 문제 해결에 대한 자세한 정보는 [오류 메시지와 함께 EC2 배포 작업이 실패함 `No such file`](troubleshooting.md#troubleshooting-ec2-deploy) 섹션을 참조하세요.

# 자습서: CodePipeline을 사용하여 Docker 이미지를 빌드하고 Amazon ECR에 푸시(V2 유형)
<a name="tutorials-ecr-build-publish"></a>

이 자습서는 소스 코드를 변경한 후 Docker 이미지를 실행하고 Amazon ECR에 푸시하는 빌드 작업을 CodePipeline에서 생성하는 데 도움이 됩니다. 또한 이 자습서에서는 푸시된 이미지를 배포하는 Amazon ECS 배포 작업을 추가하는 방법을 보여줍니다.

**중요**  
콘솔에서 파이프라인을 생성하는 과정에서 CodePipeline은 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

**참고**  
이 자습서는 GitHub 소스 리포지토리가 있는 CodePipeline 파이프라인에 대한 ECRBuildAndPublish 빌드 작업과 Amazon ECS 클러스터에 배포하기 위한 Amazon ECS 표준 작업을 위한 것입니다. CodePipeline에서 Amazon ECS에서 CodeDeploy로의 블루/그린 배포 작업을 위해 ECR 이미지 리포지토리를 소스로 사용하는 파이프라인을 활용하는 자습서는 [자습서: Amazon ECR 소스 및 ECS-to-CodeDeploy 배포를 사용하여 파이프라인 생성](tutorials-ecs-ecr-codedeploy.md) 섹션을 참조하세요.

**중요**  
이 작업은 CodePipeline 관리형 CodeBuild 컴퓨팅을 사용하여 빌드 환경에서 명령을 실행합니다. 명령 작업을 실행하면 AWS CodeBuild에서 별도의 요금이 발생합니다.

## 사전 조건
<a name="tutorials-ecr-build-publish-prereqs"></a>

이 자습서를 이용하여 CD 파이프라인을 만들려면 먼저 몇 가지 리소스를 갖춰야 합니다. 다음은 시작하기 위해 필요한 항목입니다.

**참고**  
이러한 모든 리소스는 동일한 AWS 리전 내에 생성되어야 합니다.
+ 이 자습서에 다음을 추가할 소스 제어 리포지토리(이 자습서에서는 GitHub 사용)입니다.
  + 1단계에서는 소스 리포지토리에 샘플 Dockerfile을 CodePipeline의 ECRBuildAndPublish 빌드 작업에 대한 입력 아티팩트로 추가합니다.
  + 2단계에서는 CodePipeline의 Amazon ECS 표준 배포 작업에 대한 요구 사항으로 샘플 imagedefinitions.json 파일을 소스 리포지토리에 추가합니다.
+ Dockerfile에서 빌드한 이미지가 포함된 Amazon ECR 이미지 리포지토리입니다. 자세한 내용은 *Amazon Elastic Container Registry 사용 설명서*의 [리포지토리 생성](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) 및 [이미지 푸시](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html)를 참조하세요.
+ 이미지 리포지토리와 동일한 리전에서 생성된 Amazon ECS 클러스터 및 서비스입니다. 자세한 내용은 *Amazon Elastic Container Service 개발자 안내서*의 [클러스터 생성](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create_cluster.html) 및 [서비스 생성](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service.html)을 참조하세요.

이러한 사전 조건을 모두 갖췄으면 이제 자습서를 이용하여 CD 파이프라인을 만들 수 있습니다.

## 1단계: 소스 리포지토리에 Dockerfile 추가
<a name="tutorials-ecr-build-publish-file"></a>

이 자습서는 ECRBuildAndPublish 작업을 사용하여 Docker 이미지를 빌드하고 해당 이미지를 Amazon ECR로 푸시합니다. CodePipeline의 관리형 컴퓨팅 작업은 CodeBuild를 사용하여 ECR 로그인 및 이미지 푸시 명령을 실행합니다. `buildspec.yml` 파일을 소스 코드 리포지토리에 추가하여 CodeBuild가 작업을 수행하는 방식을 지정하지 않아도 됩니다. 이 예제에서는 다음과 같이 리포지토리의 Dockerfile만 제공합니다.

이 샘플 텍스트를 붙여 넣어 `Dockerfile` 파일을 생성합니다. 이 샘플 Dockerfile은 사전 조건의 ECR 이미지 지침에 사용된 샘플과 동일합니다.

```
FROM public.ecr.aws/amazonlinux/amazonlinux:latest

# Install dependencies
RUN yum update -y && \
 yum install -y httpd

# Install apache and write hello world message
RUN echo 'Hello World!' > /var/www/html/index.html

# Configure apache
RUN echo 'mkdir -p /var/run/httpd' >> /root/run_apache.sh && \
 echo 'mkdir -p /var/lock/httpd' >> /root/run_apache.sh && \
 echo '/usr/sbin/httpd -D FOREGROUND' >> /root/run_apache.sh && \
 chmod 755 /root/run_apache.sh

EXPOSE 80

CMD /root/run_apache.sh
```

**`Dockerfile` 파일을 해당 소스 리포지토리에 추가하려면**

1. 텍스트 편집기를 연 후 위의 Dockerfile을 복사하여 새 파일에 붙여 넣습니다.

1. `Dockerfile` 파일을 커밋한 후 소스 리포지토리에 푸시합니다.

   1. 파일을 추가합니다.

      ```
      git add .
      ```

   1. 변경 내용을 커밋합니다.

      ```
      git commit -m "Adding Dockerfile."
      ```

   1. 커밋을 푸시합니다.

      ```
      git push
      ```

   파일을 리포지토리의 최상위 디렉터리에 배치합니다.

   ```
   / Dockerfile
   ```

## 2단계: 소스 리포지토리에 imagedefinitions.json 파일 추가
<a name="w2aac13b9c15"></a>

이 자습서에서는 CodePipeline의 Amazon ECS 표준 배포 작업을 사용하여 컨테이너를 Amazon ECS 클러스터에 배포합니다. Amazon ECS 표준 배포 작업에는 이미지 이름과 URI가 포함된 imagedefinitions.json 파일이 필요합니다. imagedefinitions.json 파일에 대한 자세한 내용은 [Amazon ECS 표준 배포 작업을 위한 imagedefinitions.json 파일](file-reference.md#pipelines-create-image-definitions) 섹션을 참조하세요.

이 샘플 텍스트를 붙여 넣어 `imagedefinitions.json` 파일을 생성합니다. `hello-world`와 같은 Dockerfile의 이름을 사용하고 이미지가 저장된 Amazon ECR 리포지토리의 URI를 사용합니다.

```
[
  {
    "name": "hello-world",
    "imageUri": "ACCOUNT-ID.dkr.ecr.us-east-1.amazonaws.com/actions/image-repo"
  }
]
```

**`imagedefinitions.json` 파일을 해당 소스 리포지토리에 추가하려면**

1. 텍스트 편집기를 연 후 위의 예제를 복사하여 새 파일에 붙여 넣습니다.

1. `imagedefinitions.json` 파일을 커밋한 후 소스 리포지토리에 푸시합니다.

   1. 파일을 추가합니다.

      ```
      git add .
      ```

   1. 변경 내용을 커밋합니다.

      ```
      git commit -m "Adding imagedefinitions.json."
      ```

   1. 커밋을 푸시합니다.

      ```
      git push
      ```

   파일을 리포지토리의 최상위 디렉터리에 배치합니다.

   ```
   / imagedefinitions.json
   ```

## 3단계: 파이프라인 생성
<a name="tutorials-ecr-build-publish-pipeline"></a>

CodePipeline 마법사를 사용하여 파이프라인 스테이지를 생성하고, 소스 리포지토리를 연결합니다.

**파이프라인을 생성하려면**

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔을 엽니다.

1. [**Welcome**] 페이지, [**Getting started**] 페이지 또는 [**Pipelines**] 페이지에서 **Create pipeline(파이프라인 생성)**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 **MyPipeline**을 입력합니다.

1. CodePipeline은 특성과 가격이 다른 V1 및 V2 유형 파이프라인을 제공합니다. V2 유형은 콘솔에서 선택할 수 있는 유일한 유형입니다. 자세한 내용은 [파이프라인 유형](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)을 참조하세요. CodePipeline에 대한 요금 정보는 [요금](https://aws.amazon.com/codepipeline/pricing/)을 참조하세요.

1. **서비스 역할**에서 **새 서비스 역할**을 선택하여CodePipeline이 IAM에 서비스 역할을 생성하도록 허용합니다.

1. [**Advanced settings**]의 설정은 기본값 그대로 두고, [**Next**]를 선택합니다.

1. **3단계: 소스 스테이지 추가** 페이지에서 소스 스테이지를 추가합니다.

   1. **소스 공급자**에서 **GitHub(GitHub 앱 사용)**를 선택합니다.

   1. **연결**에서 기존 연결을 선택하거나 새로 생성합니다. GitHub 소스 작업에 대한 연결을 만들거나 관리하려면 [GitHub 연결](connections-github.md)을 참조하세요.

   1. **리포지토리 이름**에서 GitHub 리포지토리의 이름을 선택합니다.

   1. **기본 브랜치**에서 파이프라인을 수동으로 시작하거나 Git 태그가 아닌 소스 이벤트로 시작할 때 지정할 브랜치를 선택합니다. 변경 소스가 트리거가 아니거나 파이프라인 실행이 수동으로 시작된 경우 기본 브랜치의 HEAD 커밋이 사용됩니다.

   **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가** 페이지에서 **다른 빌드 공급자**를 선택하고 **ECRBuildAndPublish**를 선택합니다.  
![\[\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/ecrbuild-wizard.png)

   1. **ECR 리포지토리 이름**에서 이미지 리포지토리를 선택합니다.

   1. **다음**을 선택합니다.

1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **6단계: 배포 스테이지 추가** 페이지에서 **배포 스테이지 건너뛰기**를 선택합니다. 다음 단계에서 ECS 작업을 추가합니다.

1. **7단계: 검토** 페이지에서 파이프라인 구성을 검토하고 **파이프라인 생성을** 선택하여 파이프라인을 생성합니다.

1. 파이프라인을 편집하여 파이프라인에 Amazon ECS 배포 작업을 추가합니다.

   1. 오른쪽 위에서 **편집**을 선택합니다.

   1. 다이어그램의 하단에서 **\$1 단계 추가**를 선택합니다. **Stage name(스테이지 이름)**에서 이름(예: **Deploy**)을 입력합니다.

   1. **\$1 Add action group(작업 그룹 추가)**을 선택합니다.

   1. **작업 이름**에 이름을 입력하세요.

   1. **작업 공급자**에서 Amazon ECR을 선택합니다. **리전**이 파이프라인 리전으로 기본 설정되도록 합니다.

   1. **입력 아티팩트**에서 `SourceArtifact`와 같은 소스 작업에서 입력 아티팩트를 선택합니다.

   1. **클러스터 이름**에서 해당 서비스가 실행 중인 Amazon ECS 클러스터를 선택합니다.

   1. **서비스 이름**에서 업데이트할 서비스를 선택합니다.

   1. **저장**을 선택합니다.

   1. 편집 중인 스테이지에서 **완료**를 선택합니다. AWS CodePipeline 창에서 **저장**을 선택한 다음 경고 메시지에서 **저장**을 선택합니다.

   1. 변경 사항을 제출하고 파이프라인 빌드를 시작하려면 **변경 사항 배포**를 선택한 다음 **릴리스**를 선택하세요.

1. 파이프라인이 실행된 후 파이프라인 구조 및 상태를 확인합니다.  
![\[\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/ecrbuild-ecsaction.png)

1. 파이프라인이 성공적으로 실행되면 **세부 정보 보기**를 선택하여 작업에 대한 로그를 보고 관리형 컴퓨팅 작업 출력을 확인합니다.  
![\[\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/ecrbuild-logs.png)

1. 실패한 작업 문제를 해결합니다. 예를 들어, imagedefinitions.json 파일이 소스 리포지토리에 없는 경우 ECS 배포 작업이 실패할 수 있습니다. 다음은 imagedefinitions.json 파일이 누락된 경우 표시되는 오류 메시지의 예입니다.  
![\[\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/ecrbuild-ecsdebug.png)

## 4단계: 파이프라인 테스트
<a name="tutorials-ecr-build-publish-test"></a>

파이프라인에는 end-to-end네이티브 AWS 지속적 배포를 실행하기 위한 모든 것이 있어야 합니다. 이제 소스 리포지토리에 코드 변경을 푸시하여 파이프라인 기능을 테스트해 보겠습니다.

**파이프라인을 테스트하려면**

1. 구성된 소스 리포지토리에 대한 코드를 변경하고 커밋한 후 변경 사항을 푸시합니다.

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔을 엽니다.

1. 목록에서 파이프라인을 선택합니다.

1. 단계를 수행하면서 파이프라인 진행 상황을 관찰합니다. 파이프라인이 완료되면 코드 변경 사항으로 생성된 Docker 이미지를 ECR로 푸시하는 작업이 수행됩니다.

# 자습서: CodePipeline을 사용하여 Amazon EKS에 배포
<a name="tutorials-eks-deploy"></a>

이 자습서는 CodePipeline에서 Amazon EKS에서 구성한 클러스터에 코드를 배포하는 배포 작업을 생성하는 데 도움이 됩니다.

EKS 작업은 퍼블릭 및 프라이빗 EKS 클러스터를 모두 지원합니다. 프라이빗 클러스터는 EKS에서 권장하는 유형이지만 두 유형 모두 지원됩니다.

**참고**  
콘솔에서 파이프라인을 생성하는 과정에서 CodePipeline은 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

**참고**  
이 작업은 CodePipeline 관리형 CodeBuild 컴퓨팅을 사용하여 빌드 환경에서 명령을 실행합니다. 명령 작업을 실행하면 AWS CodeBuild에서 별도의 요금이 발생합니다.

**참고**  
`EKS` 배포 작업은 V2 유형 파이프라인에서만 사용할 수 있습니다.

## 사전 조건
<a name="tutorials-eks-deploy-prereqs"></a>

이 자습서를 이용하여 CD 파이프라인을 만들려면 먼저 몇 가지 리소스를 갖춰야 합니다. 다음은 시작하기 위해 필요한 항목입니다.

**참고**  
이러한 모든 리소스는 동일한 AWS 리전 내에 생성되어야 합니다.
+ 샘플 `deployment.yaml` 파일을 추가할 소스 제어 리포지토리(이 자습서에서는 GitHub 사용).
+ 아래 [3단계: IAM에서 CodePipeline 서비스 역할 정책 업데이트](#tutorials-eks-deploy-role)를 사용하여 이 작업에 대한 권한으로 업데이트할 기존 CodePipeline 서비스 역할을 사용해야 합니다. 필요한 권한은 생성하는 클러스터 유형에 따라 다릅니다. 자세한 내용은 [서비스 역할 정책 권한](action-reference-EKS.md#action-reference-EKS-service-role) 단원을 참조하십시오.
+ ECR 또는 이미지 리포지토리로 푸시한 작업 이미지 및 리포지토리 태그입니다.

이러한 사전 조건을 모두 갖췄으면 이제 자습서를 이용하여 CD 파이프라인을 만들 수 있습니다.

## 1단계: (선택 사항) Amazon EKS에서 클러스터 생성
<a name="tutorials-eks-deploy-cluster"></a>

퍼블릭 또는 프라이빗 엔드포인트를 사용하여 EKS 클러스터를 생성하도록 선택할 수 있습니다.

다음 단계에서는 EKS에서 퍼블릭 또는 프라이빗 클러스터를 생성합니다. 클러스터를 이미 생성한 경우 이 단계는 선택 사항입니다.

### Amazon EKS에서 퍼블릭 클러스터 생성
<a name="tutorials-eks-deploy-cluster-public"></a>

이 단계에서는 EKS에서 클러스터를 생성합니다.

**퍼블릭 클러스터 생성**

1. EKS 콘솔을 열고 **클러스터 생성**을 선택합니다.

1. **이름**에서 클러스터의 이름을 지정합니다. **다음**을 선택합니다.

1. **생성(Create)**을 선택합니다.

### Amazon EKS에서 프라이빗 클러스터 생성
<a name="tutorials-eks-deploy-cluster-private"></a>

프라이빗 엔드포인트가 있는 클러스터를 생성하기로 선택한 경우 프라이빗 서브넷만 연결하고 인터넷에 연결되어 있는지 확인합니다.

프라이빗 엔드포인트를 사용하여 클러스터를 생성하려면 다음 5가지 하위 단계를 따르세요.

**콘솔을 사용하여 VPC를 만들려면 다음을 수행하세요.**

1. VPC 콘솔을 열고 **VPC 생성**을 선택합니다.

1. **VPC 설정**에서 **VPC 등**을 선택합니다.

1. 퍼블릭 서브넷 1개와 프라이빗 서브넷 4개를 생성하도록 선택합니다. **VPC 생성**을 선택합니다.

1. 서브넷 페이지에서 **프라이빗**을 선택합니다.

**VPC에서 프라이빗 서브넷 확인**

1. VPC로 이동하여 VPC ID를 선택하여 VPC 세부 정보 페이지를 엽니다.

1. VPC 세부 정보 페이지에서 **리소스 맵**을 선택합니다.

1. 다이어그램을 보고 프라이빗 서브넷을 기록해 둡니다. 서브넷은 퍼블릭 또는 프라이빗 상태를 나타내는 레이블과 함께 표시되며 각 서브넷은 라우팅 테이블에 매핑됩니다.  
![\[\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/eks-deploy-subnets.png)

   프라이빗 클러스터에는 모든 프라이빗 서브넷이 있습니다.

1. 퍼블릭 서브넷을 생성하여 NAT 게이트웨이를 호스트합니다. 한 번에 하나의 인터넷 게이트웨이만 하나의 VPC에 연결할 수 있습니다.

**퍼블릭 서브넷에서 NAT 게이트웨이를 생성합니다.**

1. 퍼블릭 서브넷에서 NAT 게이트웨이를 생성합니다. VPC 콘솔로 이동한 다음 **인터넷 게이트웨이**를 선택합니다. **인터넷 게이트웨이 생성**을 선택합니다.

1. 이름에 인터넷 게이트웨이의 이름을 입력합니다. **인터넷 게이트웨이 생성**을 선택합니다.

트래픽을 NAT 게이트웨이로 전달하도록 프라이빗 서브넷의 라우팅 테이블을 업데이트합니다.

**프라이빗 서브넷의 라우팅 테이블에 NAT 게이트웨이 추가**

1. VPC로 이동한 후 **서브넷**을 선택합니다.

1. 각 프라이빗 서브넷에 대해 해당 서브넷을 선택한 다음 세부 정보 페이지에서 해당 서브넷의 라우팅 테이블을 선택하고 **라우팅 테이블 편집**을 선택합니다.

1. 인터넷 트래픽을 NAT 게이트웨이로 전달하도록 프라이빗 서브넷의 라우팅 테이블을 업데이트합니다. **경로 추가**를 선택합니다. 추가할 옵션에서 **NAT 게이트웨이**를 선택합니다. 생성한 인터넷 게이트웨이를 선택합니다.

1. 퍼블릭 서브넷의 사용자 지정 라우팅 테이블을 생성합니다. 퍼블릭 서브넷의 네트워크 액세스 제어 목록(ACL)이 프라이빗 서브넷의 인바운드 트래픽을 허용하는지 확인합니다.

1. **변경 사항 저장**을 선택합니다.

이 단계에서는 EKS에서 클러스터를 생성합니다.

**프라이빗 클러스터 생성**

1. EKS 콘솔을 열고 **클러스터 생성**을 선택합니다.

1. **이름**에서 클러스터의 이름을 지정합니다. **다음**을 선택합니다.

1. VPC 및 기타 구성 정보를 지정합니다. **생성(Create)**을 선택합니다.

EKS 클러스터는 퍼블릭 또는 프라이빗 클러스터일 수 있습니다. 이 단계는 프라이빗 엔드포인트만 있는 클러스터를 위한 것입니다. 클러스터가 프라이빗인지 확인합니다.

## 2단계: Amazon EKS에서 프라이빗 클러스터 구성
<a name="tutorials-eks-deploy-cluster-private-configure"></a>

이 단계는 프라이빗 클러스터를 생성한 경우에만 적용됩니다. 이 단계는 프라이빗 엔드포인트만 있는 클러스터를 위한 것입니다.

**클러스터 구성**

1. **네트워킹** 탭 아래의 EKS 클러스터에서만 프라이빗 서브넷을 연결합니다. [1단계: (선택 사항) Amazon EKS에서 클러스터 생성](#tutorials-eks-deploy-cluster) 아래 **VPC 내 프라이빗 서브넷 확인** 섹션에서 캡처한 프라이빗 서브넷을 연결합니다.

1. CodePipeline은 파이프라인의 S3 아티팩트 버킷에서 아티팩트를 저장하고 검색하므로 프라이빗 서브넷이 인터넷에 액세스할 수 있는지 확인합니다.

## 3단계: IAM에서 CodePipeline 서비스 역할 정책 업데이트
<a name="tutorials-eks-deploy-role"></a>

이 단계에서는 클러스터에 연결하는 데 CodePipeline에 필요한 권한으로 `cp-service-role`와 같은 기존 CodePipeline 서비스 역할을 업데이트합니다. 기존 역할이 없는 경우 새 역할을 생성합니다.

다음 단계에 따라 CodePipeline 서비스 역할을 업데이트합니다.

**CodePipeline 서비스 역할 정책을 업데이트하려면**

1. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)에서 IAM 콘솔을 엽니다.

1. 콘솔 대시보드에서 **역할**을 선택합니다.

1. `cp-service-role`와 같은 CodePipeline 서비스 역할을 조회합니다.

1. 새 인라인 정책을 추가합니다.

1. **정책 편집기**에 다음 정책을 입력합니다.
   + 퍼블릭 클러스터의 경우 다음 권한을 추가합니다.

------
#### [ JSON ]

****  

     ```
     {
         "Version":"2012-10-17",		 	 	 
     
         "Statement": [
             {
                 "Sid": "EksClusterPolicy",
                 "Effect": "Allow",
                 "Action": "eks:DescribeCluster",
                 "Resource": "arn:aws:eks:us-east-1:111122223333:cluster/my-cluster"
             },
             {
                 "Sid": "EksVpcClusterPolicy",
                 "Effect": "Allow",
                 "Action": [
                     "ec2:DescribeDhcpOptions",
                     "ec2:DescribeNetworkInterfaces",
                     "ec2:DescribeRouteTables",
                     "ec2:DescribeSubnets",
                     "ec2:DescribeSecurityGroups",
                     "ec2:DescribeVpcs"
                 ],
                 "Resource": [
                     "*"
                 ]
             }
         ]
     }
     ```

------
   + 프라이빗 클러스터의 경우 다음 권한을 추가합니다. 프라이빗 클러스터에는 해당하는 경우 VPC에 대한 추가 권한이 필요합니다.

------
#### [ JSON ]

****  

     ```
     {
         "Version":"2012-10-17",		 	 	 
     
         "Statement": [
             {
                 "Sid": "EksClusterPolicy",
                 "Effect": "Allow",
                 "Action": "eks:DescribeCluster",
                 "Resource": "arn:aws:eks:us-east-1:111122223333:cluster/my-cluster"
             },
             {
                 "Sid": "EksVpcClusterPolicy",
                 "Effect": "Allow",
                 "Action": [
                     "ec2:DescribeDhcpOptions",
                     "ec2:DescribeNetworkInterfaces",
                     "ec2:DescribeRouteTables",
                     "ec2:DescribeSubnets",
                     "ec2:DescribeSecurityGroups",
                     "ec2:DescribeVpcs"
                 ],
                 "Resource": [
                     "*"
                 ]
             },
             {
                 "Effect": "Allow",
                 "Action": "ec2:CreateNetworkInterface",
                 "Resource": "*",
                 "Condition": {
                     "StringEqualsIfExists": {
                         "ec2:Subnet": [
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-03ebd65daeEXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0e377f6036EXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0db658ba1cEXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0db658ba1cEXAMPLE"
                         ]
                     }
                 }
             },
             {
                 "Effect": "Allow",
                 "Action": "ec2:CreateNetworkInterfacePermission",
                 "Resource": "*",
                 "Condition": {
                     "ArnEquals": {
                         "ec2:Subnet": [
                             "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-03ebd65daeEXAMPLE",
                             "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-0e377f6036EXAMPLE",
                             "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-0db658ba1cEXAMPLE",
                             "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-0db658ba1cEXAMPLE"
                         ]
                     }
                 }
             },
             {
                 "Effect": "Allow",
                 "Action": "ec2:DeleteNetworkInterface",
                 "Resource": "*",
                 "Condition": {
                     "StringEqualsIfExists": {
                         "ec2:Subnet": [
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-03ebd65daeEXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0e377f6036EXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0db658ba1cEXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0db658ba1cEXAMPLE"
                         ]
                     }
                 }
             }
         ]
     }
     ```

------

1. **정책 업데이트**를 선택합니다.

## 4단계: CodePipeline 서비스 역할에 대한 액세스 항목 생성
<a name="tutorials-eks-deploy-access-entry"></a>

이 단계에서는 클러스터에 액세스 항목을 생성하여 관리형 액세스 정책과 함께 3단계에서 업데이트한 CodePipeline 서비스 역할을 추가합니다.

1. EKS 콘솔에서 EKS 클러스터로 이동합니다.

1. **액세스** 탭을 선택합니다.

1. **IAM 액세스 항목**에서 **액세스 항목 생성**을 선택합니다.

1. **IAM 보안 주체 ARN**에 `cp-service-role`와 같이 작업에 대해 방금 업데이트한 역할을 입력합니다. **다음**을 선택합니다.

1. **2단계: 액세스 정책 추가** 페이지의 **정책 이름**에서 `AmazonEKSClusterAdminPolicy`와 같은 액세스에 대한 관리형 정책을 선택합니다. **정책 추가**를 선택합니다. **다음**을 선택합니다.
**참고**  
이는 CodePipeline 작업이 Kubernetes와 대화하는 데 사용하는 정책입니다. 가장 좋은 방법은 관리 정책이 아닌 최소 권한으로 정책의 권한을 축소하려면 대신 사용자 지정 정책을 연결하는 것입니다.

1. **검토** 페이지에서 생성을 선택합니다.

## 5단계: 소스 리포지토리 생성 및 `helm chart` 구성 파일 추가
<a name="tutorials-eks-deploy-source"></a>

이 단계에서는 작업에 적합한 구성 파일(Kubernetes 매니페스트 파일 또는 헬름 차트)을 생성하고 소스 리포지토리에 구성 파일을 저장합니다. 구성에 적합한 파일을 사용합니다. 자세한 내용은 [https://kubernetes.io/docs/reference/kubectl/quick-reference/](https://kubernetes.io/docs/reference/kubectl/quick-reference/) 또는 [https://helm.sh/docs/topics/charts/](https://helm.sh/docs/topics/charts/)를 참조하세요.
+ Kubernetes의 경우 매니페스트 파일을 사용합니다.
+ 헬름의 경우 헬름 차트를 사용합니다.

1. 리포지토리를 생성하거나 기존 GitHub 리포지토리를 사용합니다.

1. 아래 예제와 같이 헬름 차트 파일에 대한 새 구조를 리포지토리에 생성합니다.

   ```
   mychart
   |-- Chart.yaml
   |-- charts
   |-- templates
   |   |-- NOTES.txt
   |   |-- _helpers.tpl
   |   |-- deployment.yaml
   |   |-- ingress.yaml
   |   `-- service.yaml
   `-- values.yaml
   ```

1. 파일을 리포지토리의 최상위 디렉터리에 배치합니다.

## 6단계: 파이프라인 생성
<a name="tutorials-eks-deploy-pipeline"></a>

CodePipeline 마법사를 사용하여 파이프라인 스테이지를 생성하고, 소스 리포지토리를 연결합니다.

**파이프라인을 생성하려면**

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔을 엽니다.

1. [**Welcome**] 페이지, [**Getting started**] 페이지 또는 [**Pipelines**] 페이지에서 **Create pipeline(파이프라인 생성)**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 **MyEKSPipeline**을 입력합니다.

1. CodePipeline은 특성과 가격이 다른 V1 및 V2 유형 파이프라인을 제공합니다. V2 유형은 콘솔에서 선택할 수 있는 유일한 유형입니다. 자세한 내용은 [파이프라인 유형](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)을 참조하세요. CodePipeline에 대한 요금 정보는 [요금](https://aws.amazon.com/codepipeline/pricing/)을 참조하세요.

1. **서비스 역할**에서 3단계에서 업데이트한 서비스 역할을 선택합니다.

1. [**Advanced settings**]의 설정은 기본값 그대로 두고, [**Next**]를 선택합니다.

1. **3단계: 소스 스테이지 추가** 페이지의 **소스 공급자**에서 **GitHub 리포지토리에 대한 연결을 생성하도록** 선택합니다.

1. **4단계: 빌드 스테이지 추가** 페이지에서 **건너뛰기**를 선택합니다.

1. **5단계: 배포 스테이지 추가** 페이지에서 **Amazon EKS**를 선택합니다.  
![\[Deploy configuration form with Helm selected, showing fields for release name and chart location.\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/eks-action-example.png)

   1. **배포 구성 유형**에서 **헬름**을 선택합니다.

   1. **헬름 차트 위치**에 `my-release`와 같은 릴리스 이름을 입력합니다. **헬름 차트 위치**에 `mychart`와 같은 헬름 차트 파일의 경로를 입력합니다.

   1. **다음**을 선택합니다.

1. **6단계: 검토** 페이지에서 파이프라인 구성을 검토하고 **파이프라인 생성**을 선택하여 파이프라인을 생성합니다.  
![\[\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/eks-deploy-pipeline.png)

1. 파이프라인이 성공적으로 실행되면 **세부 정보 보기**를 선택하여 작업에 대한 로그를 보고 작업 출력을 확인합니다.

# 자습서: 컴퓨팅으로 명령을 실행하는 파이프라인 생성(V2 유형)
<a name="tutorials-commands"></a>

이 자습서에서는 빌드 단계에서 명령 작업을 사용하여 제공된 빌드 명령을 지속적으로 실행하는 파이프라인을 구성합니다. 명령 작업에 대한 자세한 내용은 [명령 작업 참조](action-reference-Commands.md) 섹션을 참조하세요.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

## 사전 조건
<a name="tutorials-commands-prereq"></a>

다음 항목이 있어야 합니다.
+ GitHub 리포지토리. [자습서: GitHub 파이프라인 소스와 함께 전체 복제 사용](tutorials-github-gitclone.md)에 생성한 GitHub 리포지토리를 사용할 수 있습니다.

## 1단계: 소스 파일 생성 및 GitHub 리포지토리에 푸시
<a name="tutorials-commands-push"></a>

이 섹션에서는 파이프라인이 소스 스테이지에 대해 사용하는 리포지토리에 예제 소스 파일을 생성하고 푸시합니다. 이 예제에서는 다음을 생성하고 푸시합니다.
+ `README.txt` 파일.

**소스 파일을 생성하려면**

1. 다음 텍스트를 사용하여 파일을 생성합니다.

   ```
   Sample readme file
   ```

1. 파일을 `README.txt`(으)로 저장합니다.

**GitHub 리포지토리에 파일을 푸시하려면**

1.  리포지토리에 파일을 푸시하거나 업로드합니다. 이러한 파일은 **파이프라인 생성** 마법사가 AWS CodePipeline에서 배포 작업을 위해 생성한 소스 아티팩트입니다. 파일은 로컬 디렉터리에 다음과 같이 나타납니다.

   ```
   README.txt
   ```

1. 로컬 컴퓨터의 복제된 리포지토리에서 Git 명령줄을 사용하려면 다음과 같이 합니다.

   1. 다음 명령을 실행하여 모든 파일을 한 번에 스테이징합니다.

      ```
      git add -A
      ```

   1. 다음 명령을 실행하여 커밋 메시지와 함께 파일을 커밋합니다.

      ```
      git commit -m "Added source files"
      ```

   1. 다음 명령을 실행하여 로컬 리포지토리의 파일을 리포지토리에 푸시합니다.

      ```
      git push
      ```

## 2단계: 파이프라인 생성
<a name="tutorials-commands-pipeline"></a>

이 단원에서는 다음 작업을 통해 파이프라인을 생성합니다.
+ 소스 파일이 저장되는 리포지토리에 대한 GitHub(GitHub 앱 사용) 작업이 있는 소스 스테이지입니다.
+ 명령 작업이 있는 빌드 스테이지입니다.

**마법사를 사용하여 파이프라인을 생성하려면**

1. 에 로그인 AWS Management Console 하고 [http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) CodePipeline 콘솔을 엽니다.

1. [**Welcome**] 페이지, [**Getting started**] 페이지 또는 [**Pipelines**] 페이지에서 **Create pipeline(파이프라인 생성)**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 **MyCommandsPipeline**을 입력합니다.

1. CodePipeline은 특성과 가격이 다른 V1 및 V2 유형 파이프라인을 제공합니다. V2 유형은 콘솔에서 선택할 수 있는 유일한 유형입니다. 자세한 내용은 [파이프라인 유형](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)을 참조하세요. CodePipeline에 대한 요금 정보는 [요금](https://aws.amazon.com/codepipeline/pricing/)을 참조하세요.

1. **서비스 역할**에서 **새 서비스 역할**을 선택하여CodePipeline이 IAM에 서비스 역할을 생성하도록 허용합니다.
**참고**  
기존 서비스 역할을 사용하는 경우 명령 작업을 사용하려면 서비스 역할에 대해 다음 권한을 추가해야 합니다. 서비스 역할 정책 문의 리소스 기반 권한을 사용하여 파이프라인 리소스 수준으로 권한 범위를 좁힙니다. 자세한 내용은 [서비스 역할 정책 권한](action-reference-Commands.md#action-reference-Commands-policy)에서 정책 예제를 참조하세요.  
logs:CreateLogGroup
logs:CreateLogStream
logs:PutLogEvents

1. [**Advanced settings**]의 설정은 기본값 그대로 두고, [**Next**]를 선택합니다.

1. **3단계: 소스 스테이지 추가** 페이지에서 소스 스테이지를 추가합니다.

   1. **소스 공급자**에서 **GitHub(GitHub 앱 사용)**를 선택합니다.

   1. **연결**에서 기존 연결을 선택하거나 새로 생성합니다. GitHub 소스 작업에 대한 연결을 만들거나 관리하려면 [GitHub 연결](connections-github.md)을 참조하세요.

   1. **리포지토리 이름**에서 GitHub.com 리포지토리의 이름을 선택합니다.

   1. **기본 브랜치**에서 파이프라인을 수동으로 시작하거나 Git 태그가 아닌 소스 이벤트로 시작할 때 지정할 브랜치를 선택합니다. 변경 소스가 트리거가 아니거나 파이프라인 실행이 수동으로 시작된 경우 기본 브랜치의 HEAD 커밋이 사용됩니다. 선택적으로 필터링(트리거)을 사용하여 웹후크를 지정할 수도 있습니다. 자세한 내용은 [트리거 및 필터링을 사용하여 시작 파이프라인 자동화](pipelines-triggers.md) 단원을 참조하십시오.

   **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가**에서 **명령**을 선택합니다.
**참고**  
명령 작업을 실행하면 AWS CodeBuild에서 별도의 요금이 발생합니다.

   다음 명령을 입력합니다.

   ```
   ls
   echo hello world
   cat README.txt
   echo pipeline Execution Id is #{codepipeline.PipelineExecutionId}
   ```

   **다음**을 선택합니다.  
![\[명령 작업이 있는 새 파이프라인에 대한 4단계: 빌드 스테이지 추가 페이지\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/commands-wizard-screen.png)

1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **6단계: 배포 스테이지 추가** 페이지에서 **배포 스테이지 건너뛰기**를 선택한 다음 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **7단계: 검토**에서 정보를 검토한 다음 **파이프라인 생성을** 선택합니다.

1. 작업을 생성하기 위한 마지막 단계로, 작업에 환경 변수를 추가하여 작업에 대한 출력 변수를 생성합니다. 명령 작업에서 **편집**을 선택합니다. **편집** 화면에서 **변수 네임스페이스** 필드에 `compute`를 입력하여 작업에 대한 변수 네임스페이스를 지정합니다.

   CodeBuild 출력 변수 `AWS_Default_Region`을 추가한 다음 **변수 추가**를 선택합니다.  
![\[명령 작업에 대한 편집 페이지\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/commands-output-edit-var.png)

## 3단계: 파이프라인 실행 및 빌드 명령 확인
<a name="tutorials-commands-update"></a>

변경 사항을 릴리스하여 파이프라인을 실행합니다. 실행 기록, 빌드 로그 및 출력 변수를 확인하여 빌드 명령이 실행되었는지 확인합니다.

**작업 로그 및 출력 변수를 보려면**

1. 파이프라인이 성공적으로 실행되면 작업에 대한 로그와 출력을 볼 수 있습니다.

1. 작업의 출력 변수를 보려면 **기록**을 선택한 다음 **타임라인**을 선택합니다.

   작업에 추가된 출력 변수를 봅니다. 명령 작업의 출력은 작업 리전으로 확인된 출력 변수를 보여줍니다.  
![\[작업 리전으로 확인된 출력 변수를 보여주는 명령 작업의 출력\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/commands-output-variable.png)

1. 작업에 대한 로그를 보려면 성공한 명령 작업의 **세부 정보 보기**를 선택합니다. 명령 작업에 대한 로그를 봅니다.  
![\[명령 작업에 대한 로그의 예\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/commands-output-logs.png)

# 자습서: Git 태그를 사용하여 파이프라인 시작하기
<a name="tutorials-github-tags"></a>

이 자습서에서는 Git 태그 트리거 유형에 대해 소스 작업이 구성된 GitHub 리포지토리에 연결되는 파이프라인을 생성합니다. 커밋에서 Git 태그가 생성되면 파이프라인이 시작됩니다. 이 예제에서는 태그 이름의 구문을 기반으로 태그를 필터링할 수 있는 파이프라인을 만드는 방법을 보여줍니다. Glog 패턴을 사용한 필터링에 대한 자세한 내용은 [구문에서 glob 패턴 작업](syntax-glob.md)을 참조하세요.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

이 자습서는 `CodeStarSourceConnection` 작업 유형을 통해 GitHub에 연결합니다.

**참고**  
이 기능은 아시아 태평양(홍콩), 아프리카(케이프타운), 중동(바레인) 또는 유럽(취리히) 리전에서는 사용할 수 없습니다. 사용 가능한 다른 작업을 참조하려면 [CodePipeline과 제품 및 서비스 통합](integrations.md)을 참조하세요. 유럽(밀라노) 리전에서 이 조치를 고려할 경우 [Bitbucket Cloud, GitHub, GitHub Enterprise Server, GitLab.com 및 GitLab 자체 관리형 작업용 CodeStarSourceConnection](action-reference-CodestarConnectionSource.md)의 참고 사항을 참조하세요.

**Topics**
+ [사전 조건](#tutorials-github-tags-prereq)
+ [1단계: CloudShell을 열고 리포지토리 복제](#w2aac13c16c15)
+ [2단계: Git 태그에 트리거할 파이프라인 생성](#tutorials-github-tags-pipeline)
+ [3단계: 릴리스용 커밋에 태그 지정](#w2aac13c16c19)
+ [4단계: 변경 사항 릴리스 및 로그 보기](#tutorials-github-tags-view)

## 사전 조건
<a name="tutorials-github-tags-prereq"></a>

시작하기 전에 다음을 수행해야 합니다.
+ GitHub 계정을 사용하여 GitHub 리포지토리를 만듭니다.
+ GitHub 자격 증명을 준비합니다. AWS Management Console 를 사용하여 연결을 설정하면 GitHub 자격 증명으로 로그인하라는 메시지가 표시됩니다.

## 1단계: CloudShell을 열고 리포지토리 복제
<a name="w2aac13c16c15"></a>

명령줄 인터페이스를 사용하여 리포지토리를 복제하고, 커밋하고, 태그를 추가할 수 있습니다. 이 자습서에서는 명령줄 인터페이스용 CloudShell 인스턴스를 시작합니다.

1.  AWS Management Console에 로그인합니다.

1. 상단 탐색 모음에서 AWS 아이콘을 선택합니다. AWS Management Console 디스플레이의 기본 페이지입니다.

1. 상단 탐색 모음에서 AWS CloudShell 아이콘을 선택합니다. CloudShell이 열립니다. CloudShell 환경이 생성되는 동안 기다립니다.
**참고**  
CloudShell 아이콘이 보이지 않는 경우 [CloudShell에서 지원하는 리전](https://docs.aws.amazon.com/cloudshell/latest/userguide/faq-list.html#regions-available)에 있는지 확인하세요. 이 자습서에서는 사용자가 미국 서부(오레곤) 리전에 있다고 가정합니다.

1. GitHub에서 리포지토리로 이동합니다. **코드**를 선택한 다음 **HTTPS**를 선택합니다. 경로를 복사합니다. Git 리포지토리를 복제할 주소는 클립보드에 복사됩니다.

1. 다음 명령을 실행하여 리포지토리를 복제합니다.

   ```
   git clone https://github.com/<account>/MyGitHubRepo.git
   ```

1. 프롬프트가 표시되면 GitHub 계정 `Username`과 `Password`를 입력합니다. `Password` 항목의 경우 계정 암호 대신 사용자가 만든 토큰을 사용해야 합니다.

## 2단계: Git 태그에 트리거할 파이프라인 생성
<a name="tutorials-github-tags-pipeline"></a>

이 단원에서는 다음 작업을 통해 파이프라인을 생성합니다.
+ GitHub 리포지토리 및 작업에 대한 연결이 있는 소스 단계입니다.
+ 빌드 작업이 있는 AWS CodeBuild 빌드 단계입니다.

**마법사를 사용하여 파이프라인을 생성하려면**

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔에 로그인합니다.

1. **Welcome(시작)** 페이지, **시작하기** 페이지 또는 **Pipelines(파이프라인)** 페이지에서 **파이프라인 생성**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 **MyGitHubTagsPipeline**을 입력합니다.

1. **파이프라인 유형**에서는 기본 선택을 **V2**로 유지합니다. 파이프라인 유형은 특성과 가격이 다릅니다. 자세한 내용은 [파이프라인 유형](pipeline-types.md) 단원을 참조하십시오.

1. **Service role(서비스 역할)**에서 **New service role(새 서비스 역할)**을 선택합니다.
**참고**  
역할을 생성하지 않고 기존 CodePipeline 서비스 역할을 사용할 경우 서비스 역할 정책에 대한 `codestar-connections:UseConnection` IAM 권한을 추가해야 합니다. CodePipeline 서비스 역할에 대한 지침은 [CodePipeline 서비스 역할에 권한 추가](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)를 참조하세요.

1. **고급 설정**에서 기본값을 그대로 둡니다. [**아티팩트 스토어(Artifact store)**]에서 [**기본 위치(Default location)**]를 선택하여 파이프라인에 대해 선택한 리전의 파이프라인에 대해 기본값으로 지정된 Amazon S3 아티팩트 버킷과 같은 기본 아티팩트 스토어를 사용합니다.
**참고**  
이는 소스 코드에 대한 소스 버킷이 아닙니다. 이 파이프라인은 아티팩트 스토어입니다. S3 버킷과 같은 개별 아티팩트 스토어는 각 파이프라인에 필요합니다.

   **다음**을 선택합니다.

1. **3단계: 소스 스테이지 추가** 페이지에서 소스 스테이지를 추가합니다.

   1. **소스 공급자**에서 **GitHub(GitHub 앱 사용)**를 선택합니다.

   1. **연결**에서 기존 연결을 선택하거나 새로 생성합니다. GitHub 소스 작업에 대한 연결을 만들거나 관리하려면 [GitHub 연결](connections-github.md)을 참조하세요.

   1. **리포지토리 이름**에서 GitHub 리포지토리의 이름을 선택합니다.

   1. **기본 브랜치**에서 파이프라인을 수동으로 시작하거나 Git 태그가 아닌 소스 이벤트로 시작할 때 지정할 브랜치를 선택합니다. 변경 소스가 트리거가 아니거나 파이프라인 실행이 수동으로 시작된 경우 기본 브랜치의 HEAD 커밋이 사용됩니다.

   1. **Webhook 이벤트**의 **필터 유형**에서 **태그**를 선택합니다.

      **태그 또는 패턴** 필드에 `release*`를 입력합니다.
**중요**  
트리거 유형의 Git 태그로 시작하는 파이프라인은 WebhookV2 이벤트용으로 구성되며 파이프라인을 시작하는 데 Webhook 이벤트(모든 푸시 이벤트에 대한 변경 감지)를 사용하지 않습니다.

   **다음**을 선택합니다.

1. **Add build stage(빌드 스테이지 추가)**에서 빌드 스테이지를 추가합니다.

   1. **빌드 공급자**에서 **AWS CodeBuild**를 선택합니다. **리전**이 파이프라인 리전으로 기본 설정되도록 합니다.

   1. **프로젝트 생성**을 선택합니다.

   1. **프로젝트 이름**에 이 빌드 프로젝트의 이름을 입력합니다.

   1. **환경 이미지**에서 **이미지 관리**를 선택합니다. [**Operating system**]에서 [**Ubuntu**]를 선택합니다.

   1. **실행 시간**에서 **표준**을 선택합니다. **이미지**에서 **aws/codebuild/standard:5.0**을 선택합니다.

   1. **서비스 역할**에서 **New service role(새 서비스 역할)**을 선택합니다.
**참고**  
CodeBuild 서비스 역할의 이름을 기록해 둡니다. 이 자습서의 마지막 단계를 수행하려면 역할 이름이 필요합니다.

   1. [**Buildspec**]의 [**빌드 사양(Build specifications)**]에서 [**빌드 명령 삽입(Insert build commands)**]을 선택합니다. **편집기로 전환**을 선택하고 **빌드 명령**에 다음을 붙여 넣습니다.

      ```
      version: 0.2
      #env:
        #variables:
           # key: "value"
           # key: "value"
        #parameter-store:
           # key: "value"
           # key: "value"
        #git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
          #commands:
            # - command
            # - command
        #pre_build:
          #commands:
            # - command
            # - command
        build:
          commands:
            - 
        #post_build:
          #commands:
            # - command
            # - command
      artifacts:
        files:
           - '*'
          # - location
        name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. **Continue to CodePipeline(CodePipeline으로 계속)**을 선택합니다. 그러면 CodePipeline 콘솔로 돌아가고 구성을 위해 빌드 명령을 사용하는 CodeBuild 프로젝트가 생성됩니다. 빌드 프로젝트는 서비스 역할을 사용하여 AWS 서비스 권한을 관리합니다. 이 단계는 몇 분이 걸릴 수 있습니다.

   1. **다음**을 선택합니다.

1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **6단계: 배포 단계 추가** 페이지에서 **배포 단계 건너뛰기를** 선택한 다음 다시 **건너뛰기를** 선택하여 경고 메시지를 수락합니다. **다음**을 선택합니다.

1. **7단계: 검토**에서 **파이프라인 생성을** 선택합니다.

## 3단계: 릴리스용 커밋에 태그 지정
<a name="w2aac13c16c19"></a>

파이프라인을 생성하고 Git 태그를 지정한 후 GitHub 리포지토리에서 커밋에 태그를 지정할 수 있습니다. 이 단계에서는 `release-1` 태그로 커밋에 태그를 지정합니다. Git 리포지토리의 각 커밋에는 고유한 Git 태그가 있어야 합니다. 커밋을 선택하고 태그를 지정하면 여러 브랜치의 변경 사항을 파이프라인 배포에 통합할 수 있습니다. 단, 태그 이름 릴리스는 GitHub의 릴리스 개념에는 적용되지 않습니다.

1. 태그를 지정할 복사한 커밋 ID를 참조하세요. 각 브랜치의 커밋을 보려면 CloudShell 터미널에서 다음 명령을 입력하여 태그하려는 커밋 ID를 캡처합니다.

   ```
   git log
   ```

1. CloudShell 터미널에서 커밋에 태그를 지정하고 오리진으로 푸시하는 명령을 입력합니다. 커밋에 태그를 지정한 후 git 푸시 명령을 사용하여 태그를 오리진에 푸시합니다. 다음 예제에서는 ID `49366bd`가 있는 두 번째 커밋에 `release-1` 태그를 사용하려면 다음 명령을 입력합니다. 이 태그는 파이프라인 `release*` 태그 필터에 의해 필터링되고 파이프라인을 시작합니다.

   ```
   git tag release-1 49366bd
   ```

   ```
   git push origin release-1
   ```  
![\[\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/git-tags-pipeline.png)

## 4단계: 변경 사항 릴리스 및 로그 보기
<a name="tutorials-github-tags-view"></a>

1. 파이프라인이 성공적으로 실행되면 성공적으로 완료된 빌드 단계에서 **로그 보기**를 선택합니다.

   **로그**에서 CodeBuild 빌드 출력을 확인합니다. 명령은 입력된 변수의 값을 출력합니다.

1. **기록** 페이지에서 **트리거** 열을 확인합니다. 트리거 유형 **GitTag : release-1**을 확인합니다.

# 자습서: 파이프라인을 시작하기 위한 풀 요청의 브랜치 이름 필터링(V2 유형)
<a name="tutorials-github-featurebranches"></a>

이 자습서에서는 풀 요청을 필터링하는 트리거 구성으로 파이프라인을 시작하도록 소스 작업이 구성된 GitHub.com 리포지토리에 연결되는 파이프라인을 생성합니다. 지정된 브랜치에 대해 지정된 풀 요청 이벤트가 발생하면 파이프라인이 시작됩니다. 이 예제에서는 브랜치 이름에 대해 필터링할 수 있는 파이프라인을 만드는 방법을 보여줍니다. 트리거 작업에 대한 자세한 내용은 [푸시 및 풀 요청 이벤트 유형에 대한 필터 추가(CLI)](pipelines-filter.md#pipelines-filter-cli) 섹션을 참조하세요. glob 형식의 정규식 패턴을 사용한 필터링에 대한 자세한 내용은 [구문에서 glob 패턴 작업](syntax-glob.md) 섹션을 참조하세요.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

이 자습서는 `CodeStarSourceConnection` 작업 유형을 통해 GitHub.com에 연결합니다.

**Topics**
+ [사전 조건](#tutorials-github-featurebranches-prereq)
+ [1단계: 지정된 브랜치에 대한 풀 요청을 시작할 파이프라인 생성](#tutorials-github-featurebranches-pipeline)
+ [2단계: GitHub.com에서 풀 요청을 생성 및 병합하여 파이프라인 실행 시작](#tutorials-github-featurebranches-pullrequest)

## 사전 조건
<a name="tutorials-github-featurebranches-prereq"></a>

시작하기 전에 다음을 수행해야 합니다.
+ GitHub.com 계정을 사용하여 GitHub.com 리포지토리를 만듭니다.
+ GitHub 자격 증명을 준비합니다. AWS Management Console 를 사용하여 연결을 설정하면 GitHub 자격 증명으로 로그인하라는 메시지가 표시됩니다.

## 1단계: 지정된 브랜치에 대한 풀 요청을 시작할 파이프라인 생성
<a name="tutorials-github-featurebranches-pipeline"></a>

이 단원에서는 다음 작업을 통해 파이프라인을 생성합니다.
+ GitHub.com 리포지토리 및 작업에 대한 연결이 있는 소스 스테이지입니다.
+ 빌드 작업이 있는 AWS CodeBuild 빌드 단계입니다.

**마법사를 사용하여 파이프라인을 생성하려면**

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔에 로그인합니다.

1. **Welcome(시작)** 페이지, **시작하기** 페이지 또는 **Pipelines(파이프라인)** 페이지에서 **파이프라인 생성**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 **MyFilterBranchesPipeline**을 입력합니다.

1. **파이프라인 유형**에서는 기본 선택을 **V2**로 유지합니다. 파이프라인 유형은 특성과 가격이 다릅니다. 자세한 내용은 [파이프라인 유형](pipeline-types.md) 단원을 참조하십시오.

1. **Service role(서비스 역할)**에서 **New service role(새 서비스 역할)**을 선택합니다.
**참고**  
역할을 생성하지 않고 기존 CodePipeline 서비스 역할을 사용할 경우 서비스 역할 정책에 대한 `codeconnections:UseConnection` IAM 권한을 추가해야 합니다. CodePipeline 서비스 역할에 대한 지침은 [CodePipeline 서비스 역할에 권한 추가](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)를 참조하세요.

1. **고급 설정**에서 기본값을 그대로 둡니다. [**아티팩트 스토어(Artifact store)**]에서 [**기본 위치(Default location)**]를 선택하여 파이프라인에 대해 선택한 리전의 파이프라인에 대해 기본값으로 지정된 Amazon S3 아티팩트 버킷과 같은 기본 아티팩트 스토어를 사용합니다.
**참고**  
이는 소스 코드에 대한 소스 버킷이 아닙니다. 이 파이프라인은 아티팩트 스토어입니다. S3 버킷과 같은 개별 아티팩트 스토어는 각 파이프라인에 필요합니다.

   **다음**을 선택합니다.

1. **3단계: 소스 스테이지 추가** 페이지에서 소스 스테이지를 추가합니다.

   1. **소스 공급자**에서 **GitHub(GitHub 앱 사용)**를 선택합니다.

   1. **연결**에서 기존 연결을 선택하거나 새로 생성합니다. GitHub 소스 작업에 대한 연결을 만들거나 관리하려면 [GitHub 연결](connections-github.md)을 참조하세요.

   1. **리포지토리 이름**에서 GitHub.com 리포지토리의 이름을 선택합니다.

   1. **트리거 유형**에서 **필터 지정**을 선택합니다.

      **이벤트 유형**에서 **풀 요청**을 선택합니다. 풀 요청의 모든 이벤트를 선택하여 생성, 업데이트 또는 종료된 풀 요청에 대해 이벤트가 발생하도록 합니다.

      **브랜치**의 **포함** 필드에 `main*`을 입력합니다.  
![\[이벤트 유형이 풀 요청인 트리거에 대해 main* 값으로 선택된 브랜치 포함 옵션을 보여주는 이미지\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/pullreq-example-triggers-edit.png)
**중요**  
이 트리거 유형으로 시작하는 파이프라인은 WebhookV2 이벤트용으로 구성되며 파이프라인을 시작하는 데 Webhook 이벤트(모든 푸시 이벤트에 대한 변경 감지)를 사용하지 않습니다.

   **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가**의 **빌드 공급자**에서 **AWS CodeBuild**를 선택합니다. **리전**이 파이프라인 리전으로 기본 설정되도록 합니다. [자습서: Git 태그를 사용하여 파이프라인 시작하기](tutorials-github-tags.md)의 지침에 따라 빌드 프로젝트를 선택하거나 생성합니다. 이 작업은 이 자습서에서 파이프라인을 생성하는 데 필요한 두 번째 단계로만 사용됩니다.

1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **6단계: 배포 단계 추가** 페이지에서 **배포 단계 건너뛰기를** 선택한 다음 다시 **건너뛰기를** 선택하여 경고 메시지를 수락합니다. **다음**을 선택합니다.

1. **7단계: 검토**에서 **파이프라인 생성을** 선택합니다.

## 2단계: GitHub.com에서 풀 요청을 생성 및 병합하여 파이프라인 실행 시작
<a name="tutorials-github-featurebranches-pullrequest"></a>

이 섹션에서는 풀 요청을 생성하고 병합합니다. 이렇게 하면 파이프라인이 시작되며, 열린 풀 요청에 대해 한 번 실행되고 닫힌 풀 요청에 대해 한 번 실행됩니다.

**풀 요청을 생성하고 파이프라인을 시작하려면**

1. GitHub.com에서 기능 브랜치의 README.md를 변경하고 `main` 브랜치에 풀 요청을 제기하여 풀 요청을 생성합니다. `Update README.md for PR`과 같은 메시지로 변경 사항을 커밋합니다.

1. 파이프라인은 풀 요청에 대한 **소스** 메시지가 **PR용 README.md 업데이트**로 표시되는 소스 개정으로 시작됩니다.  
![\[풀 요청에 대한 소스 메시지를 다음 텍스트와 함께 보여주는 이미지 Update README.md for PR\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/pullreq-example.png)

1. **History(기록)**를 선택합니다. 파이프라인 실행 기록에서 파이프라인 실행을 시작한 CREATED 및 MERGED 풀 요청 상태 이벤트를 확인합니다.  
![\[파이프라인 실행을 시작한 CREATED 및 MERGED 풀 요청 상태 이벤트가 표시되는 파이프라인 실행 기록을 보여주는 이미지\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/pullreq-example-history.png)

# 자습서: 파이프라인 수준 변수 사용
<a name="tutorials-pipeline-variables"></a>

이 자습서에서는 파이프라인 수준에서 변수를 추가하는 파이프라인을 만들고 변수 값을 출력하는 CodeBuild 빌드 작업을 실행합니다.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

**Topics**
+ [사전 조건](#tutorials-pipeline-variables-prereq)
+ [1단계: 파이프라인 및 빌드 프로젝트 생성](#tutorials-pipeline-variables-pipeline)
+ [2단계: 변경 사항 릴리스 및 로그 보기](#tutorials-pipeline-variables-view)

## 사전 조건
<a name="tutorials-pipeline-variables-prereq"></a>

시작하기 전에 다음을 수행해야 합니다.
+ CodeCommit 리포지토리를 생성합니다.
+ 리포지토리에 .txt 파일을 추가합니다

## 1단계: 파이프라인 및 빌드 프로젝트 생성
<a name="tutorials-pipeline-variables-pipeline"></a>

이 단원에서는 다음 작업을 통해 파이프라인을 생성합니다.
+ CodeCommit 리포지토리에 대한 연결이 있는 소스 스테이지입니다.
+ 빌드 작업이 있는 AWS CodeBuild 빌드 단계입니다.

**마법사를 사용하여 파이프라인을 생성하려면**

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔에 로그인합니다.

1. **Welcome(시작)** 페이지, **시작하기** 페이지 또는 **Pipelines(파이프라인)** 페이지에서 **파이프라인 생성**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 **MyVariablesPipeline**을 입력합니다.

1. **파이프라인 유형**에서는 기본 선택을 **V2**로 유지합니다. 파이프라인 유형은 특성과 가격이 다릅니다. 자세한 내용은 [파이프라인 유형](pipeline-types.md) 단원을 참조하십시오.

1. **Service role(서비스 역할)**에서 **New service role(새 서비스 역할)**을 선택합니다.
**참고**  
역할을 생성하지 않고 기존 CodePipeline 서비스 역할을 사용할 경우 서비스 역할 정책에 대한 `codeconnections:UseConnection` IAM 권한을 추가해야 합니다. CodePipeline 서비스 역할에 대한 지침은 [CodePipeline 서비스 역할에 권한 추가](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)를 참조하세요.

1. **변수**에서 **변수 추가**를 선택합니다. **이름**에 `timeout`를 입력합니다. **기본값**에 1000을 입력합니다. 설명에 **Timeout** 설명을 입력합니다.

   그러면 파이프라인 실행이 시작될 때 값을 선언할 수 있는 변수가 생성됩니다. 변수 이름은 `[A-Za-z0-9@\-_]+`와 일치해야 하며 빈 문자열 이외의 모두 가능합니다.

1. **고급 설정**에서 기본값을 그대로 둡니다. [**아티팩트 스토어(Artifact store)**]에서 [**기본 위치(Default location)**]를 선택하여 파이프라인에 대해 선택한 리전의 파이프라인에 대해 기본값으로 지정된 Amazon S3 아티팩트 버킷과 같은 기본 아티팩트 스토어를 사용합니다.
**참고**  
이는 소스 코드에 대한 소스 버킷이 아닙니다. 이 파이프라인은 아티팩트 스토어입니다. S3 버킷과 같은 개별 아티팩트 스토어는 각 파이프라인에 필요합니다.

   **다음**을 선택합니다.

1. **3단계: 소스 스테이지 추가** 페이지에서 소스 스테이지를 추가합니다.

   1. **소스 공급자**에서 **AWS CodeCommit**을 선택합니다.

   1. **리포지토리 이름** 및 **브랜치 이름**에서 리포지토리와 브랜치를 선택합니다.

   **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가**에서 빌드 스테이지를 추가합니다.

   1. **빌드 공급자**에서 **AWS CodeBuild**를 선택합니다. **리전**이 파이프라인 리전으로 기본 설정되도록 합니다.

   1. **프로젝트 생성**을 선택합니다.

   1. **프로젝트 이름**에 이 빌드 프로젝트의 이름을 입력합니다.

   1. **환경 이미지**에서 **이미지 관리**를 선택합니다. [**Operating system**]에서 [**Ubuntu**]를 선택합니다.

   1. **실행 시간**에서 **표준**을 선택합니다. **이미지**에서 **aws/codebuild/standard:5.0**을 선택합니다.

   1. **서비스 역할**에서 **New service role(새 서비스 역할)**을 선택합니다.
**참고**  
CodeBuild 서비스 역할의 이름을 기록해 둡니다. 이 자습서의 마지막 단계를 수행하려면 역할 이름이 필요합니다.

   1. [**Buildspec**]의 [**빌드 사양(Build specifications)**]에서 [**빌드 명령 삽입(Insert build commands)**]을 선택합니다. **편집기로 전환**을 선택하고 **빌드 명령**에 다음을 붙여 넣습니다. buildspec에서는 고객 변수 `$CUSTOM_VAR1`을 사용하여 빌드 로그의 파이프라인 변수를 출력합니다. 다음 단계에서 `$CUSTOM_VAR1` 출력 변수를 환경 변수로 생성합니다.

      ```
      version: 0.2
      #env:
        #variables:
           # key: "value"
           # key: "value"
        #parameter-store:
           # key: "value"
           # key: "value"
        #git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
          #commands:
            # - command
            # - command
        #pre_build:
          #commands:
            # - command
            # - command
        build:
          commands:
            - echo $CUSTOM_VAR1
        #post_build:
          #commands:
            # - command
            # - command
      artifacts:
        files:
           - '*'
          # - location
        name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. **Continue to CodePipeline(CodePipeline으로 계속)**을 선택합니다. 그러면 CodePipeline 콘솔로 돌아가고 구성을 위해 빌드 명령을 사용하는 CodeBuild 프로젝트가 생성됩니다. 빌드 프로젝트는 서비스 역할을 사용하여 AWS 서비스 권한을 관리합니다. 이 단계는 몇 분이 걸릴 수 있습니다.

   1. **환경 변수 - 선택 사항**에서 파이프라인 수준 변수로 확인된 빌드 작업의 입력 변수로 환경 변수를 만들려면 **환경 변수 추가**를 선택합니다.** 그러면 buildspec에 지정된 변수가 `$CUSTOM_VAR1`으로 생성됩니다. **이름**에 `CUSTOM_VAR1`를 입력합니다. **값**에는 `#{variables.timeout}`를 입력합니다. **유형**에서 `Plaintext`를 선택합니다.

      환경 변수의 `#{variables.timeout}` 값은 파이프라인 수준 변수 네임스페이스`variables`와 7단계에서 파이프라인에 대해 `timeout` 생성된 파이프라인 수준 변수를 기반으로 합니다.

   1. **다음**을 선택합니다.

1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **6단계: 배포 단계 추가** 페이지에서 **배포 단계 건너뛰기를** 선택한 다음 다시 **건너뛰기를** 선택하여 경고 메시지를 수락합니다. **다음**을 선택합니다.

1. **7단계: 검토**에서 **파이프라인 생성을** 선택합니다.

## 2단계: 변경 사항 릴리스 및 로그 보기
<a name="tutorials-pipeline-variables-view"></a>

1. 파이프라인이 성공적으로 실행되면 성공적으로 완료된 빌드 단계에서 **세부 정보 보기**를 선택합니다.

   세부 정보 페이지에서 **로그** 탭을 선택합니다. CodeBuild 빌드 출력을 확인합니다. 명령은 입력된 변수의 값을 출력합니다.

1. 왼쪽 탐색 창에서 **기록**을 선택합니다.

   최근 실행을 선택한 다음, **변수** 탭을 선택합니다. 파이프라인 변수의 확인된 값을 확인합니다.

# 자습서: 간단한 파이프라인 생성(S3 버킷)
<a name="tutorials-simple-s3"></a>

파이프라인을 생성하는 가장 쉬운 방법은 AWS CodePipeline 콘솔에서 **파이프라인 생성** 마법사를 사용하는 것입니다.

이 자습서에서는 버전이 지정된 S3 소스 버킷과 CodeDeploy를 사용하여 샘플 애플리케이션을 릴리스하는 두 단계 파이프라인을 생성합니다.

**참고**  
Amazon S3가 파이프라인의 소스 공급자인 경우, 소스 파일을 .zip 하나로 압축하고 그 .zip을 소스 버킷에 업로드할 수 있습니다. 압축이 풀린 단일 파일을 업로드할 수도 있지만 .zip 파일을 예상하는 다운스트림 작업은 실패합니다.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

이 간단한 파이프라인을 생성한 후 다른 단계를 추가한 다음 단계 간 전환을 비활성화하고 활성화합니다.

**중요**  
이 절차에서 파이프라인에 추가하는 많은 작업에는 파이프라인을 생성하기 전에 생성해야 하는 AWS 리소스가 포함됩니다. 소스 작업에 대한 AWS 리소스는 항상 파이프라인을 생성하는 리전과 동일한 AWS 리전에서 생성해야 합니다. 예를 들어, 미국 동부(오하이오) 리전에서 파이프라인을 생성하는 경우, CodeCommit 리포지토리도 미국 동부(오하이오) 리전에 있어야 합니다.  
파이프라인을 생성할 때 교차 리전 작업을 추가할 수 있습니다. 교차 리전 작업에 대한 AWS 리소스는 작업을 실행하려는 리전과 동일한 AWS 리전에 있어야 합니다. 자세한 내용은 [CodePipeline에 교차 리전 작업 추가](actions-create-cross-region.md) 단원을 참조하십시오.

시작하기 전에 [CodePipeline 시작하기](getting-started-codepipeline.md) 단원의 사전 조건을 충족해야 합니다.

**Topics**
+ [1단계: 애플리케이션에 대한 S3 소스 버킷 생성](#s3-create-s3-bucket)
+ [2단계: Amazon EC2 Windows 인스턴스 생성 및 CodeDeploy 에이전트 설치](#S3-create-instances)
+ [3단계: CodeDeploy에서 애플리케이션 생성](#S3-create-deployment)
+ [4단계: CodePipeline에서 첫 번째 파이프라인 생성](#s3-create-pipeline)
+ [(선택 사항) 5단계: 파이프라인에 다른 단계 추가](#s3-add-stage)
+ [(선택 사항) 6단계: CodePipeline에서 단계 간 전환 비활성화 및 활성화](#s3-configure-transitions)
+ [7단계: 리소스 정리](#s3-clean-up)

## 1단계: 애플리케이션에 대한 S3 소스 버킷 생성
<a name="s3-create-s3-bucket"></a>

버전이 지정된 위치에 소스 파일이나 애플리케이션을 저장할 수 있습니다. 이 자습서에서는 샘플 애플리케이션 파일에 대한 S3 버킷을 생성하고 해당 버킷의 버전 관리를 활성화합니다. 버전 관리를 활성화한 후 샘플 애플리케이션을 해당 버킷에 복사합니다.

**S3 버킷을 생성하려면,**

1. 에서 콘솔에 로그인합니다 AWS Management Console. S3 콘솔을 엽니다.

1. **버킷 생성**을 선택합니다.

1. [**Bucket Name**]에서 버킷 이름을 입력합니다(예: **awscodepipeline-demobucket-example-date**).
**참고**  
Amazon S3에 있는 모든 버킷 이름은 고유해야 하므로, 예에 표시된 이름이 아닌, 사용자 고유의 이름을 사용하세요. 이름에 날짜만 추가하여 간단히 예제 이름을 변경해도 됩니다. 이 자습서의 나머지 부분에서 이 이름을 사용할 것이므로 이름을 메모해 둡니다.

   **리전**에서 **미국 서부(오레곤)**과 같은 파이프라인을 생성할 리전을 선택한 다음, **버킷 생성**을 선택합니다.

1. 버킷이 생성되면 성공적으로 수행했다는 배너가 표시됩니다. [**Go to bucket details**]를 선택합니다.

1. [**Properties**] 탭에서 [**Versioning**]을 선택합니다. [**Enable versioning**]을 선택한 다음 [**Save**]를 선택합니다.

   버전 관리가 활성화되면 Amazon S3이 버킷의 모든 객체 버전을 저장합니다.

1. [**Permissions**] 탭에서 기본값을 그대로 둡니다. S3의 버킷 및 객체 권한에 대한 자세한 내용은 [정책에서 권한 지정](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html) 단원을 참조하십시오.

1. 그런 다음 샘플을 다운로드하여 로컬 컴퓨터의 폴더나 디렉토리에 저장합니다.

   1. 다음 중 하나를 선택합니다. Windows Server 인스턴스에 대해 이 자습서의 단계를 수행하려는 경우 `SampleApp_Windows.zip`을 선택합니다.
      + CodeDeploy를 사용하여 Amazon Linux 인스턴스에 배포하려는 경우 여기에서 샘플 애플리케이션을 다운로드하세요. [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip)
      + CodeDeploy를 사용하여 Windows Server 인스턴스에 배포하려는 경우 여기에서 샘플 애플리케이션을 다운로드하세요. [SampleApp\$1Windows.zip](samples/SampleApp_Windows.zip)

      샘플 애플리케이션에는 CodeDeploy로 배포하기 위한 다음 파일이 포함되어 있습니다.
      + `appspec.yml` – 애플리케이션 사양 파일(AppSpec file)은 CodeDeploy에서 배포를 관리하는 데 사용하는 [YAML](http://www.yaml.org) 형식의 파일입니다. AppSpec 파일에 대한 자세한 내용은 *AWS CodeDeploy 사용 설명서*의 [CodeDeploy AppSpec 파일 참조](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html)를 참조하세요.
      + `index.html` – 인덱스 파일에는 배포된 샘플 애플리케이션의 홈 페이지가 포함되어 있습니다.
      + `LICENSE.txt` – 라이선스 파일에는 샘플 애플리케이션에 대한 라이선스 정보가 포함되어 있습니다.
      + 스크립트용 파일 - 샘플 애플리케이션은 스크립트를 사용하여 인스턴스의 위치에 텍스트 파일을 씁니다. 여러 CodeDeploy의 배포 수명 주기 이벤트 각각에 대해 하나의 파일이 작성됩니다.
        + (Linux 샘플만 해당) `scripts` 폴더 - 이 폴더에는 종속성을 설치하고 자동 배포를 위한 샘플 애플리케이션을 시작 및 중지하기 위한 `install_dependencies`, `start_server`, `stop_server`와 같은 쉘 스크립트가 포함되어 있습니다.
        + (Windows 샘플만 해당) `before-install.bat` – 이것은 `BeforeInstall` 배포 수명 주기 이벤트의 배치 스크립트로, 이 샘플의 이전 배포 중 기록된 이전 파일을 제거하기 위해 실행되고 인스턴스에 새 파일을 기록할 위치를 만듭니다.

   1. 압축된 파일을 다운로드합니다. 파일의 압축을 풀지 마십시오.

1. Amazon S3 콘솔에서 버킷용 파일 을 업로드합니다.

   1. **업로드**를 선택합니다.

   1. 파일을 끌어서 놓거나 **파일 추가**를 선택하고 파일을 찾아봅니다.

   1. **업로드**를 선택합니다.

## 2단계: Amazon EC2 Windows 인스턴스 생성 및 CodeDeploy 에이전트 설치
<a name="S3-create-instances"></a>

**참고**  
이 자습서는 Amazon EC2 Windows 인스턴스를 생성하기 위한 샘플 단계를 제공합니다. Amazon EC2 Linux 인스턴스를 생성하는 샘플 단계는 [3단계: Amazon EC2 Linux 인스턴스 생성 및 CodeDeploy 에이전트 설치](tutorials-simple-codecommit.md#codecommit-create-deployment) 단원을 참조하세요. 생성할 인스턴스 수를 묻는 메시지가 표시되면 **2**개의 인스턴스를 지정하십시오.

이 단계에는 샘플 애플리케이션을 배포할 Windows Server Amazon EC2 인스턴스를 생성합니다. 이 프로세스의 일부로 인스턴스에 CodeDeploy 에이전트를 설치하고 관리할 수 있는 정책이 포함된 인스턴스 역할을 생성합니다. CodeDeploy 에이전트는 인스턴스를 CodeDeploy 배포에서 사용할 수 있게 해주는 소프트웨어 패키지입니다. 또한 CodeDeploy 에이전트가 애플리케이션을 배포하는 데 사용하는 파일을 인스턴스가 가져오도록 허용하고 SSM에서 인스턴스를 관리할 수 있도록 허용하는 정책을 첨부합니다.

**인스턴스 역할을 생성하려면**

1. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)에서 IAM 콘솔을 엽니다.

1. 콘솔 대시보드에서 **역할**을 선택합니다.

1. **역할 생성**을 선택합니다.

1. **신뢰할 수 있는 유형의 엔터티 선택**에서 **AWS 서비스**를 선택합니다. **Choose a use case(사용 사례 선택)**에서 **EC2**를 선택한 후 **Next: Permissions(다음: 권한)**을 선택합니다.

1. 검색하여 **`AmazonEC2RoleforAWSCodeDeploy`**라는 정책을 선택합니다.

1. 검색하여 **`AmazonSSMManagedInstanceCore`**라는 정책을 선택합니다. **다음: 태그**를 선택합니다.

1. **다음: 검토**를 선택합니다. 역할의 이름을 입력합니다(예: **EC2InstanceRole**).
**참고**  
다음 단계를 위해 역할 이름을 적어 둡니다. 인스턴스를 생성할 때 이 역할을 선택합니다.

   **역할 생성**을 선택합니다.

**인스턴스를 시작하려면**

1. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)에서 Amazon EC2 콘솔을 엽니다.

1. 측면 탐색에서 **인스턴스**를 선택하고 페이지 상단에서 **인스턴스 시작**을 선택합니다.

1. **이름 및 태그** 아래의 **이름**에 **MyCodePipelineDemo**를 입력하세요. 그러면 인스턴스에 **Name**의 태그 **키**와 **MyCodePipelineDemo**의 태그 **값**이 할당됩니다. 나중에 샘플 애플리케이션을 인스턴스에 배포하는 CodeDeploy 애플리케이션을 생성합니다. CodeDeploy는 태그를 기반으로 배포할 인스턴스를 선택합니다.

1. **애플리케이션 및 OS 이미지(Amazon Machine Image)**에서 **Windows** 옵션을 선택합니다. (이 AMI는 **Microsoft Windows Server 2019 Base**로 설명되며 "프리 티어 사용 가능"으로 표시되고 **빠른 시작**에서 확인할 수 있습니다.)

1. **인스턴스 유형**에서 인스턴스의 하드웨어 구성으로 사용할 프리 티어 가능 `t2.micro` 유형을 선택합니다.

1. **키 페어(로그인)**에서 키 페어를 선택하거나 새로 생성합니다.

   **키 페어 없이 계속**을 선택할 수도 있습니다.
**참고**  
이 자습서의 목적상 키 페어 없이 진행할 수 있습니다. SSH를 사용하여 인스턴스에 연결하려면 키 페어를 생성하거나 사용합니다.

1. **네트워크 설정**에서 다음을 수행합니다.

   **퍼블릭 IP 자동 할당**에서 상태가 **활성화**인지 확인합니다.
   + [**Assign a security group**] 옆에 있는 [**Create a new security group**]을 선택합니다.
   + **SSH** 행의 **소스 유형**에서 **내 IP**를 선택합니다.
   + **보안 그룹 추가**를 선택하고, **HTTP**를 선택한 다음, **소스 유형**에서 **내 IP**를 선택합니다.

1. **Advanced details**(고급 세부 정보)를 확장합니다. **IAM 인스턴스 프로파일**에서 이전 절차에서 생성한 IAM 역할을 선택합니다(예: **EC2InstanceRole**).

1. **요약**에서 **인스턴스 수**에 `2`를 입력합니다.

1. **인스턴스 시작**을 선택합니다.

1. **모든 인스턴스 보기(View all instances)**를 선택하여 확인 페이지를 닫고 콘솔로 돌아갑니다.

1. [**Instances**] 페이지에서 시작 상태를 볼 수 있습니다. 인스턴스를 시작할 때 초기 상태는 `pending`입니다. 인스턴스가 시작된 후에는 상태가 `running`으로 바뀌고 퍼블릭 DNS 이름을 받습니다. [**Public DNS**] 열이 표시되지 않으면 [**Show/Hide**] 아이콘을 선택하고 [**Public DNS**]를 선택합니다.

1. 연결할 수 있도록 인스턴스가 준비될 때까지 몇 분 정도 걸릴 수 있습니다. 인스턴스가 상태 확인을 통과했는지 확인합니다. [**Status Checks**] 열에서 이 정보를 볼 수 있습니다.

## 3단계: CodeDeploy에서 애플리케이션 생성
<a name="S3-create-deployment"></a>

CodeDeploy에서 *애플리케이션*은 배포하려는 코드의 이름 형태의 식별자입니다. CodeDeploy는 이 이름을 사용하여 배포 중에 개정, 배포 구성 및 배포 그룹의 올바른 조합을 참조하도록 합니다. 이 자습서 후반부에 파이프라인을 생성할 때, 이 단계에 생성되는 CodeDeploy 애플리케이션의 이름을 선택합니다.

먼저 사용할 CodeDeploy에 대한 서비스 역할을 만듭니다. 서비스 역할을 이미 생성한 경우 다른 서비스 역할을 생성할 필요가 없습니다.

**CodeDeploy 서비스 역할을 만들려면**

1. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)에서 IAM 콘솔을 엽니다.

1. 콘솔 대시보드에서 **역할**을 선택합니다.

1. **역할 생성**을 선택합니다.

1. **신뢰할 수 있는 엔터티 선택**에서 **AWS 서비스**를 선택합니다. **사용 사례**에서 **CodeDeploy**를 선택합니다. 나열된 옵션에서 **CodeDeploy**를 선택합니다. **다음**을 선택합니다. `AWSCodeDeployRole` 관리형 정책이 역할에 연결됩니다.

1. **다음**을 선택합니다.

1. 역할 이름(예: **CodeDeployRole**)을 입력한 후 **Create role(역할 생성)**을 선택합니다.

**CodeDeploy에서 애플리케이션을 만들려면**

1. [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy)에서 CodeDeploy 콘솔을 엽니다.

1. **애플리케이션** 페이지가 표시되지 않으면 AWS CodeDeploy 메뉴에서 **애플리케이션을** 선택합니다.

1. **애플리케이션 생성**을 선택합니다.

1. **애플리케이션 이름**에 `MyDemoApplication`을 입력합니다.

1. **Compute Platform(컴퓨팅 플랫폼)**에서 **EC2/On-premises(EC2/온프레미스)**를 선택합니다.

1. **애플리케이션 생성**을 선택합니다.

**CodeDeploy에서 배포 그룹을 생성하려면**

1. 애플리케이션이 표시되는 페이지에서 **Create deployment group(배포 그룹 생성)**을 선택합니다.

1. **Deployment group name(배포 그룹 이름)**에 **MyDemoDeploymentGroup**을 입력합니다.

1. **서비스 역할**에서 앞서 생성한 서비스 역할을 선택합니다. AWS CodeDeploy에 대한 서비스 역할 [생성에 설명된 신뢰 및 권한으로 최소한 CodeDeploy를 신뢰하는 서비스 역할을](https://docs.aws.amazon.com/codedeploy/latest/userguide/getting-started-create-service-role.html) 사용해야 합니다. 서비스 역할 ARN을 가져오려면 [서비스 역할 ARN 가져오기(콘솔)](https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-create-service-role.html#getting-started-get-service-role-console)를 참조하십시오.

1. **배포 유형** 아래에서 **인 플레이스**를 선택합니다.

1. [**Environment configuration**]에서 [**Amazon EC2 Instances**] 탭을 선택합니다. **키** 필드에서 **이름**을 선택하고 **값** 필드에 **MyCodePipelineDemo**를 입력합니다.
**중요**  
EC2 인스턴스를 생성할 때 할당한 동일한 값을 여기의 **이름** 키에 대해 선택해야 합니다. **MyCodePipelineDemo**가 아닌 이름으로 인스턴스에 태그를 지정한 경우, 여기에서 해당 이름을 사용해야 합니다.

1. ** AWS Systems Manager를 사용한 에이전트 구성**에서 **지금 및 일정 업데이트를** 선택합니다. 그러면 인스턴스에 에이전트가 설치됩니다. Windows 인스턴스는 이미 SSM 에이전트로 구성되어 있으며 이제 CodeDeploy 에이전트로 업데이트됩니다.

1. **배포 설정**에서 `CodeDeployDefault.OneAtaTime`을 선택합니다.

1. **로드 밸런서**에서 **로드 밸런싱 활성화** 상자가 선택되지 않았는지 확인합니다. 이 예에서는 로드 밸런서를 설정하거나 대상 그룹을 선택할 필요가 없습니다. 확인란의 선택을 취소하면 로드 밸런서 옵션이 표시되지 않습니다.

1. **고급** 섹션에서 기본값을 그대로 둡니다.

1. [**Create deployment group**]을 선택합니다.

## 4단계: CodePipeline에서 첫 번째 파이프라인 생성
<a name="s3-create-pipeline"></a>

자습서의 이 부분에서는 파이프라인을 생성합니다. 샘플은 파이프라인을 통해 자동으로 실행됩니다.

**CodePipeline 자동화 릴리스 프로세스 생성 방법**

1. 에 로그인 AWS Management Console 하고 [http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) CodePipeline 콘솔을 엽니다.

1. [**Welcome**] 페이지, [**Getting started**] 페이지 또는 [**Pipelines**] 페이지에서 **Create pipeline(파이프라인 생성)**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 **MyFirstPipeline**을 입력합니다.
**참고**  
파이프라인에 다른 이름을 선택하는 경우, 이 자습서의 나머지 부분에서 **MyFirstPipeline** 대신 해당 이름을 사용해야 합니다. 파이프라인을 만든 후에는 해당 이름을 변경할 수 없습니다. 파이프라인 이름에는 일부 제한이 적용됩니다. 자세한 내용은 [AWS CodePipeline의 할당량](limits.md) 단원을 참조하십시오.

1. CodePipeline은 특성과 가격이 다른 V1 및 V2 유형 파이프라인을 제공합니다. V2 유형은 콘솔에서 선택할 수 있는 유일한 유형입니다. 자세한 내용은 [파이프라인 유형](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)을 참조하세요. CodePipeline에 대한 요금 정보는 [요금](https://aws.amazon.com/codepipeline/pricing/)을 참조하세요.

1. **서비스 역할**에서 다음 중 하나를 수행합니다.
   + **새 서비스 역할**을 선택하여 CodePipeline이 IAM에 새 서비스 역할을 생성하도록 허용합니다.
   + **Existing service role(기존 서비스 역할)**을 선택하여 IAM에서 이미 생성된 서비스 역할을 사용합니다. **역할 이름**의 목록에서 서비스 역할을 선택합니다.

1. [**Advanced settings**]의 설정은 기본값 그대로 두고, [**Next**]를 선택합니다.

1. **3단계: 소스 스테이지 추가**의 **소스 공급자**에서 **Amazon S3**를 선택합니다. [**Bucket**]에 [1단계: 애플리케이션에 대한 S3 소스 버킷 생성](#s3-create-s3-bucket)에서 생성한 S3 버킷의 이름을 입력합니다. **S3 객체 키**에 파일 경로가 있거나 없는 객체 키를 입력하고 파일 확장명을 포함해야 합니다. 예를 들어, `SampleApp_Windows.zip`의 경우 다음 예제에 표시된 대로 샘플 파일 이름을 입력합니다.

   ```
   SampleApp_Windows.zip
   ```

   **다음 단계**를 선택합니다.

   [**Change detection options**] 아래에서 기본값을 그대로 둡니다. 그러면 CodePipeline이 Amazon CloudWatch Events를 사용하여 소스 버킷의 변경을 감지할 수 있습니다.

    **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가**에서 **빌드 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다. **다음**을 선택합니다.

1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **6단계: 배포 단계 추가**의 **배포 공급자**에서 **CodeDeploy를 **선택합니다. **리전** 필드는 기본적으로 파이프라인 AWS 리전 과 동일합니다. **애플리케이션 이름**에 `MyDemoApplication`을 입력하거나 **새로 고침** 버튼을 선택한 다음, 목록에서 애플리케이션 이름을 선택합니다. **배포 그룹**에서 **MyDemoDeploymentGroup**을 입력하거나, 목록에서 이를 선택한 후 **다음**을 선택합니다.
**참고**  
Deploy라는 이름은 파이프라인의 첫 단계에 Source라는 이름이 지정되는 것처럼 **4단계: 배포 단계 추가** 단계에서 생성한 단계에 기본적으로 지정되는 이름입니다.

1. **7단계: 검토**에서 정보를 검토한 다음 **파이프라인 생성을** 선택합니다.

1. 파이프라인이 실행을 시작합니다. CodePipeline 샘플이 CodeDeploy 배포의 각 Amazon EC2 인스턴스에 웹 페이지를 배포하므로 진행 사항과 성공 및 실패 메시지를 볼 수 있습니다.

축하합니다\$1 방금 CodePipeline에서 간단한 파이프라인을 생성했습니다. 파이프라인에는 두 단계가 있습니다.
+ **Source**라는 소스 단계는 S3 버킷에 저장된 버전이 지정된 샘플 애플리케이션의 변경 사항을 감지하고 이러한 변경 사항을 파이프라인으로 가져옵니다.
+ **배포** 단계는 CodeDeploy를 이용해 이러한 변경 사항을 EC2 인스턴스에 배포합니다.

이제 결과를 확인합니다.

**파이프라인이 성공적으로 실행되었는지 확인하려면**

1. 파이프라인의 초기 진행 상황을 확인합니다. 각 단계의 상태는 [**No executions yet**]에서 [**In Progress**]로 바뀌며, 다시 [**Succeeded**]나 [**Failed**] 중 하나로 바뀝니다. 파이프라인은 몇 분 내로 첫 번째 실행을 완료해야 합니다.

1. 작업 상태가 **성공**으로 표시되면 **배포** 스테이지의 상태 영역에서 **세부 정보**를 선택합니다. 그러면 CodeDeploy 콘솔이 열립니다.

1. **배포 그룹** 탭의 **배포 수명 주기 이벤트**에서 인스턴스 ID를 선택합니다. EC2 콘솔이 열립니다.

1. [**Description**] 탭의 [**Public DNS**]에서, 주소를 복사한 다음 이를 웹 브라우저의 주소 표시줄에 붙여 넣습니다. S3 버킷에 업로드한 샘플 애플리케이션에 대한 인덱스 페이지를 봅니다.

   웹페이지에 S3 버킷에 업로드한 샘플 애플리케이션이 표시됩니다.

단계, 작업, 파이프라인의 작동 방식에 대한 자세한 내용은 [CodePipeline 개념](concepts.md) 단원을 참조하십시오.

## (선택 사항) 5단계: 파이프라인에 다른 단계 추가
<a name="s3-add-stage"></a>

이제 파이프라인의 다른 단계를 추가하여 CodeDeploy를 통해 스테이징 서버에서 프로덕션 서버로 배포합니다. 먼저 CodeDeploy의 CodePipelineDemoApplication에서 또 다른 배포 그룹을 만듭니다. 그런 다음 이 배포 그룹을 사용하는 작업이 포함된 단계를 추가합니다. 다른 단계를 추가하려면 CodePipeline 콘솔 또는 AWS CLI 를 사용하여 JSON 파일의 파이프라인 구조를 검색하고 수동으로 편집한 다음 **update-pipeline** 명령을 실행하여 파이프라인을 변경 사항으로 업데이트합니다.

**Topics**
+ [CodeDeploy에서 두 번째 배포 그룹 생성](#s3-add-stage-part-1)
+ [파이프라인의 다른 단계로 배포 그룹 추가](#s3-add-stage-part-2)

### CodeDeploy에서 두 번째 배포 그룹 생성
<a name="s3-add-stage-part-1"></a>

**참고**  
자습서의 이 부분에서는 두 번째 배포 그룹을 생성하지만 이전과 동일한 Amazon EC2 인스턴스에 배포합니다. 이는 데모용일 뿐입니다. 오류가 CodePipeline에 표시되는 방식을 보여 주기 위해 고의로 실패하도록 설계되었습니다.

**CodeDeploy에서 두 번째 배포 그룹을 생성하려면**

1. [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy)에서 CodeDeploy 콘솔을 엽니다.

1. **애플리케이션**을 선택한 다음 애플리케이션 목록에서 `MyDemoApplication`을 선택합니다.

1. **배포 그룹** 탭을 선택한 다음 **Create deployment group(배포 그룹 생성)**을 선택합니다.

1. **Create deployment group(배포 그룹 생성)** 페이지의 **Deployment group name(배포 그룹 이름)**에 두 번째 배포 그룹 이름(예: **CodePipelineProductionFleet**)을 입력합니다.

1. **서비스 역할**에서 초기 배포에 사용되는 동일한 CodeDeploy 서비스 역할(CodePipeline 서비스 역할이 아님)을 선택합니다.

1. **배포 유형** 아래에서 **인 플레이스**를 선택합니다.

1. [**Environment configuration**]에서 [**Amazon EC2 Instances**] 탭을 선택합니다. **키** 상자에서 **이름**을 선택하고, **값** 상자에서 목록의 `MyCodePipelineDemo`를 선택합니다. **배포 설정**의 기본 구성을 그대로 둡니다.

1. **Deployment configuration(배포 구성)**에서 `CodeDeployDefault.OneAtaTime`을 선택합니다.

1. **로드밸런서**에서 **Enable load balancing(로드 밸런싱 활성화)**을 선택 해제합니다.

1.  [**Create deployment group**]을 선택합니다.

### 파이프라인의 다른 단계로 배포 그룹 추가
<a name="s3-add-stage-part-2"></a>

이제 다른 배포 그룹을 생성했으므로 이 배포 그룹을 사용하여 이전에 사용한 동일한 EC2 인스턴스에 배포하는 단계를 추가할 수 있습니다. CodePipeline 콘솔 또는를 사용하여이 단계를 추가할 수 AWS CLI 있습니다.

**Topics**
+ [세 번째 단계 생성(콘솔)](#s3-add-stage-part-2-console)
+ [세 번째 단계 생성(CLI)](#s3-add-stage-part-2-cli)

#### 세 번째 단계 생성(콘솔)
<a name="s3-add-stage-part-2-console"></a>

CodePipeline 콘솔을 사용하여 새 배포 그룹을 사용하는 새 단계를 추가할 수 있습니다. 이 배포 그룹이 이미 사용한 EC2 인스턴스에 배포되고 있으므로 이 단계의 배포 작업은 실패합니다.

1. 에 로그인 AWS Management Console 하고 [http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) CodePipeline 콘솔을 엽니다.

1. **이름**에서 앞에서 만든 파이프라인의 이름(MyFirstPipeline)을 선택합니다.

1. 파이프라인 세부 정보 페이지에서 [**Edit**]를 선택합니다.

1. **편집** 페이지에서 **\$1 Add stage(단계 추가)**를 선택하여 배포 단계 바로 다음에 단계를 추가합니다.  
![\[편집 화면의 + 스테이지 추가 버튼을 보여주는 이미지\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/edit-pipeline-console-pol.png)

1. **Add stage(단계 추가)**의 **Stage name(단계 이름)**에 **Production**을 입력합니다. **Add stage(단계 추가)**를 선택합니다.

1. 새 단계에서 **\$1 Add action group(작업 그룹 추가)**을 선택합니다.

1. **작업 편집**의 **작업 이름**에서 **Deploy-Second-Deployment**를 입력합니다. **작업 공급자**에서, **배포** 아래에 **CodeDeploy**를 선택합니다.

1. CodeDeploy 섹션에서 **애플리케이션 이름**에 파이프라인을 생성했을 때처럼 드롭다운 목록에서 `MyDemoApplication`을 선택합니다. **배포 그룹**에서 방금 생성한 배포 그룹(**CodePipelineProductionFleet**)을 선택합니다. **입력 아티팩트**에서 소스 작업에서 입력 아티팩트를 선택합니다. **저장**을 선택합니다.

1. **편집** 페이지에서 **저장**을 선택합니다. **파이프라인 변경 사항 저장**에서 **저장**을 선택합니다.

1. 새로운 단계가 파이프라인에 추가되었더라도 변경 사항에 의해 파이프라인이 다시 실행되도록 트리거되지 않았으므로 상태가 [**No executions yet**]으로 표시됩니다. 편집된 파이프라인이 어떻게 실행되는지를 보려면 수동으로 마지막 개정을 다시 실행해야 합니다. 파이프라인 세부 정보 페이지에서 **변경 사항 릴리스**를 선택한 다음, 메시지가 표시되면 **릴리스**를 선택합니다. 이렇게 하면 소스 작업에 지정된 각 소스 위치에서 사용 가능한 가장 최근의 개정이 파이프라인을 통해 실행됩니다.

   또는 AWS CLI 를 사용하여 파이프라인을 다시 실행하려면 로컬 Linux, macOS 또는 Unix 시스템의 터미널 또는 로컬 Windows 시스템의 명령 프롬프트에서 파이프라인 이름을 지정하여 **start-pipeline-execution** 명령을 실행합니다. 이렇게 하면 파이프라인을 통해 소스 버킷의 애플리케이션이 두 번째로 실행됩니다.

   ```
   aws codepipeline start-pipeline-execution --name MyFirstPipeline
   ```

   이 명령은 `pipelineExecutionId` 객체를 반환합니다.

1. CodePipeline 콘솔로 돌아가 파이프라인 목록에서 **MyFirstPipeline**을 선택하여 보기 페이지를 엽니다.

   파이프라인에 세 단계 및 이 세 단계를 통해 실행 중인 아티팩트의 상태가 표시됩니다. 파이프라인이 모든 단계를 통해 실행되려면 최대 5분이 소요될 수 있습니다. 앞에서와 마찬가지로 첫 번째 두 단계에는 배포 성공이 표시되지만, **Production** 단계에는 **Deploy-Second-Deployment** 작업 실패가 표시됩니다.

1. [**Deploy-Second-Deployment**] 작업에서 [**Details**]를 선택합니다. CodeDeploy 배포의 페이지로 리디렉션됩니다. 이 경우, 모든 EC2 인스턴스에 배포되는 첫 번째 인스턴스 그룹의 결과가 실패이므로 두 번째 배포 그룹에는 인스턴스가 없게 됩니다.
**참고**  
이 경우의 실패는 의도된 것으로 파이프라인 단계에 실패가 있는 경우 어떻게 되는지를 설명하기 위한 것입니다.

#### 세 번째 단계 생성(CLI)
<a name="s3-add-stage-part-2-cli"></a>

 AWS CLI 를 사용하여 파이프라인에 스테이지를 추가하는 것은 콘솔을 사용하는 것보다 더 복잡하지만 파이프라인의 구조에 대한 가시성이 향상됩니다.

**파이프라인에 대한 3번째 단계를 생성하려면**

1. 로컬 Linux, macOS 또는 Unix 머신에서 터미널 세션을 열거나 로컬 Windows 머신에서 명령 프롬프트를 열고, **get-pipeline** 명령을 실행하여 방금 생성한 파이프라인의 구조를 표시합니다. **MyFirstPipeline**의 경우, 다음 명령을 입력합니다.

   ```
   aws codepipeline get-pipeline --name "MyFirstPipeline"
   ```

   이 명령은 MyFirstPipeline의 구조를 반환합니다. 출력의 첫 번째 부분에 다음과 비슷한 내용이 표시됩니다.

   ```
   {
       "pipeline": {
           "roleArn": "arn:aws:iam::80398EXAMPLE:role/AWS-CodePipeline-Service",
           "stages": [
       ...
   ```

   출력의 마지막 부분에 파이프라인 메타데이터가 포함되고 다음과 비슷한 내용이 표시됩니다.

   ```
       ...
           ],
           "artifactStore": {
               "type": "S3"
               "location": "amzn-s3-demo-bucket",
           },
           "name": "MyFirstPipeline",
           "version": 4
       },
       "metadata": {
           "pipelineArn": "arn:aws:codepipeline:us-east-2:80398EXAMPLE:MyFirstPipeline",
           "updated": 1501626591.112,
           "created": 1501626591.112
       }
   }
   ```

1. 이 구조를 복사하여 평문 편집기에 붙여 넣은 다음 파일을 **pipeline.json**로 저장합니다. 편의를 위해 이 파일을 **aws codepipeline** 명령을 실행하는 동일한 디렉터리에 저장합니다.
**참고**  
다음과 같이 **get-pipeline**을 사용하여 JSON을 파일에 직접 파이프할 수 있습니다.  

   ```
   aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json
   ```

1. **배포** 스테이지 섹션을 복사하고 이를 처음 두 단계 이후에 붙여 넣습니다. **배포** 스테이지와 같은 배포 단계이므로 이를 세 번째 단계의 템플릿으로 사용할 것입니다.

1. 단계 이름 및 배포 그룹 세부 정보를 변경합니다.

   다음 예에서는 **배포** 단계 후 pipeline.json 파일에 추가하는 JSON을 보여 줍니다. 강조 표시된 요소를 새 값으로 편집하십시오. **배포** 스테이지와 **프로덕션** 단계를 구분하기 위해 쉼표를 포함해야 한다는 것을 기억하십시오.

   ```
   ,
   {
       "name": "Production",
        "actions": [
           {
            "inputArtifacts": [
                {
                 "name": "MyApp"
                }
              ],
             "name": "Deploy-Second-Deployment",
             "actionTypeId": {
                 "category": "Deploy",
                 "owner": "AWS",
                 "version": "1",
                 "provider": "CodeDeploy"
                 },
            "outputArtifacts": [],
            "configuration": {
                 "ApplicationName": "CodePipelineDemoApplication",
                 "DeploymentGroupName": "CodePipelineProductionFleet"
                  },
            "runOrder": 1
           }
       ]
   }
   ```

1. **get-pipeline** 명령을 사용하여 검색한 파이프라인 구조로 작업을 수행할 경우, JSON 파일에서 `metadata` 행을 제거해야 합니다. 이렇게 하지 않으면 **update-pipeline** 명령에서 사용할 수 없습니다. `"metadata": { }` 행과, `"created"`, `"pipelineARN"` 및 `"updated"` 필드를 제거합니다.

   예를 들어, 구조에서 다음 행을 삭제합니다.

   ```
   "metadata": {  
     "pipelineArn": "arn:aws:codepipeline:region:account-ID:pipeline-name",
     "created": "date",
     "updated": "date"
     }
   ```

   파일을 저장합니다.

1. 다음과 유사하게 파이프라인 JSON 파일을 지정하여 **update-pipeline** 명령을 실행합니다.

   ```
   aws codepipeline update-pipeline --cli-input-json file://pipeline.json
   ```

   이 명령은 업데이트한 파이프라인의 전체 구조를 반환합니다.
**중요**  
파일 이름 앞에 `file://`를 포함해야 합니다. 이 명령에 필수적입니다.

1.  **start-pipeline-execution** 명령을 실행하여 파이프라인의 이름을 지정합니다. 이렇게 하면 파이프라인을 통해 소스 버킷의 애플리케이션이 두 번째로 실행됩니다.

   ```
   aws codepipeline start-pipeline-execution --name MyFirstPipeline
   ```

   이 명령은 `pipelineExecutionId` 객체를 반환합니다.

1. CodePipeline 콘솔을 열고 파이프라인 목록에서 **MyFirstPipeline**을 선택합니다.

   파이프라인에 세 단계 및 이 세 단계를 통해 실행 중인 아티팩트의 상태가 표시됩니다. 파이프라인이 모든 단계를 통해 실행되려면 최대 5분이 소요될 수 있습니다. 앞에서와 마찬가지로 첫 번째 두 단계에는 배포 성공이 표시되지만, [**Production**] 단계에는 [**Deploy-Second-Deployment**] 작업이 실패했다고 표시됩니다.

1. [**Deploy-Second-Deployment**] 작업에서 [**Details**]를 선택하여 실패 세부 정보를 확인합니다. CodeDeploy 배포의 세부 정보 페이지로 리디렉션됩니다. 이 경우, 모든 EC2 인스턴스에 배포되는 첫 번째 인스턴스 그룹의 결과가 실패이므로 두 번째 배포 그룹에는 인스턴스가 없게 됩니다.
**참고**  
이 경우의 실패는 의도된 것으로 파이프라인 단계에 실패가 있는 경우 어떻게 되는지를 설명하기 위한 것입니다.

## (선택 사항) 6단계: CodePipeline에서 단계 간 전환 비활성화 및 활성화
<a name="s3-configure-transitions"></a>

파이프라인의 단계 간 전환을 활성화하거나 비활성화할 수 있습니다. 단계 간 전환을 비활성화하면 단계 간 전환을 수동으로 제어할 수 있습니다. 예를 들어 파이프라인의 처음 두 단계를 실행할 수 있지만 프로덕션에 배포할 준비가 될 때까지 또는 해당 단계의 문제나 오류를 해결하는 동안 세 번째 단계로의 전환을 비활성화할 수 있습니다.

**CodePipeline 파이프라인에서 단계 간 전환 비활성화 및 활성화 방법**

1. CodePipeline 콘솔을 열고 파이프라인 목록에서 **MyFirstPipeline**을 선택합니다.

1. 파이프라인의 세부 정보 페이지에서 이전 섹션(**프로덕션**)에서 추가한 두 번째 단계(**배포**)와 세 번째 단계 사이의 **전환 비활성화** 버튼을 선택합니다.

1. **전환 비활성화**에서 전환을 비활성화하는 사유를 입력한 후 **비활성화**를 선택합니다.

   단계 사이에 있는 화살표가 아이콘을 표시하고 색상이 변경되며 **전환 활성화** 버튼이 표시됩니다.  
![\[전환을 비활성화한 사유로 '장애 문제를 해결하는 동안 전환 비활성화'를 입력한 이미지\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/codepipeline-disabled-transition-pol.png)

1. 샘플을 S3 버킷에 다시 업로드합니다. 버킷에 버전이 지정되어 있는 경우, 이 변경 사항으로 인해 파이프라인이 시작됩니다.

1. 파이프라인의 세부 정보 페이지로 돌아간 다음 단계의 상태를 확인합니다. 파이프라인 보기가 변경되어 처음 두 단계의 진행 상황 및 성공이 표시되지만, 세 번째 단계에는 변경된 내용이 없습니다. 이 프로세스에는 몇 분이 걸릴 수 있습니다.

1. 두 단계 사이에서 **전환 활성화** 버튼을 선택하여 전환을 활성화합니다. [**Enable transition**] 대화 상자에서 [**Enable**]을 선택합니다. 몇 분 후에 단계가 실행되기 시작하고 파이프라인의 처음 두 단계를 통해 이미 실행된 아티팩트를 처리하려고 시도합니다.
**참고**  
이 세 번째 단계가 성공하도록 하려면 전환을 활성화하기 전에 CodePipelineProductionFleet 배포 그룹을 편집하고 애플리케이션을 배포할 다양한 EC2 인스턴스를 지정합니다. 이 작업을 수행하는 방법에 대한 자세한 내용은 [배포 그룹 설정 변경](https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-change-deployment-group-settings.html)을 참조하십시오. 더 많은 EC2 인스턴스를 생성하면 추가 비용이 발생할 수 있습니다.

## 7단계: 리소스 정리
<a name="s3-clean-up"></a>

이 자습서에서 생성한 리소스 중 일부를 [자습서: 4단계 파이프라인 생성](tutorials-four-stage-pipeline.md)에 사용할 수 있습니다. 예를 들어 CodeDeploy 애플리케이션 및 배포를 재사용할 수 있습니다. 클라우드 기반의 완전 관리형 빌드 서비스인 CodeBuild 등의 공급자를 통해 빌드 작업을 구성할 수 있습니다. Jenkins 등의 빌드 서버나 시스템과 함께 공급자를 사용하는 빌드 작업을 구성할 수도 있습니다.

하지만 이 자습서와 다른 자습서를 완료한 후에는 사용한 파이프라인과 리소스를 삭제해야 이 리소스를 계속 사용할 경우 부과되는 요금을 피할 수 있습니다. 먼저 파이프라인을 삭제하고 CodeDeploy 애플리케이션과 그에 연결된 Amazon EC2 인스턴스, 끝으로 S3 버킷을 삭제합니다.

**이 자습서에서 사용한 리소스를 정리하려면**

1. CodePipeline 리소스를 정리하려면 [AWS CodePipeline에서 파이프라인 삭제](pipelines-delete.md) 단원의 지침을 따릅니다.

1. CodeDeploy 리소스를 정리하려면 [리소스를 정리하려면(콘솔)](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-wordpress-clean-up.html#tutorials-wordpress-clean-up-console)의 지침을 따릅니다.

1. S3 버킷을 삭제하려면 [버킷 삭제 또는 비우기](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-or-empty-bucket.html)의 지침을 따릅니다. 더 많은 파이프라인을 생성하려는 경우, 파이프라인의 아티팩트를 저장하기 위해 생성한 S3 버킷을 삭제합니다. 이 버킷에 대한 자세한 내용은 [CodePipeline 개념](concepts.md) 단원을 참조하십시오.

# 자습서: 간단한 파이프라인 생성(CodeCommit 리포지토리)
<a name="tutorials-simple-codecommit"></a>

이 자습서에서는 CodePipeline을 이용해 CodeCommit 리포지토리에서 유지되는 코드를 단일 Amazon EC2 인스턴스에 배포합니다. CodeCommit 리포지토리에 변경 사항을 푸시하면 파이프라인이 트리거됩니다. 파이프라인은 CodeDeploy를 배포 서비스로 사용해 Amazon EC2 인스턴스에 변경 사항을 배포합니다.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

파이프라인에는 두 단계가 있습니다.
+ CodeCommit 소스 작업을 위한 소스 단계(**소스**)입니다.
+ CodeDeploy 배포 작업을 위한 배포 단계(**배포**)입니다.

를 시작하는 가장 쉬운 방법은 CodePipeline **콘솔에서 파이프라인 생성** 마법사를 사용하는 AWS CodePipeline 것입니다.

**참고**  
시작하기 전에 CodeCommit으로 작업할 Git 클라이언트를 설정해야 합니다. 관련 지침은 [CodeCommit 설정](https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up.html)을 참조하세요.

## 1단계: CodeCommit 리포지토리 생성
<a name="codecommit-create-repository"></a>

먼저 CodeCommit에서 리포지토리를 생성합니다. 파이프라인이 실행되면 이 리포지토리에서 소스 코드를 가져옵니다. CodeCommit 리포지토리에 푸시하기 전에 코드를 유지하고 업데이트할 로컬 리포지토리를 생성할 수도 있습니다.

**CodeCommit 리포지토리를 생성하려면**



1. [https://console.aws.amazon.com/codecommit/](https://console.aws.amazon.com/codecommit/)에서 CodeCommit 콘솔을 엽니다.

1. 리전 선택기에서 리포지토리와 파이프라인을 생성할 AWS 리전 을 선택합니다. 자세한 내용은 [AWS 리전 및 엔드포인트](https://docs.aws.amazon.com/general/latest/gr/rande.html)를 참조하세요.

1. **리포지토리** 페이지에서 **리포지토리 생성**을 선택합니다.

1. **리포지토리 생성** 페이지에서 **리포지토리 이름**에 해당 리포지토리의 이름(예: **MyDemoRepo**)을 입력합니다.

1. **생성(Create)**을 선택합니다.

**참고**  
이 자습서의 나머지 단계에서는 CodeCommit 리포지토리의 이름으로 **MyDemoRepo**를 사용합니다. 다른 이름을 선택하는 경우 이 자습서 전체에서 이를 사용해야 합니다.

**로컬 리포지토리를 설정하려면**

이 단계에서는 원격 CodeCommit 리포지토리에 연결할 로컬 리포지토리를 설정합니다.
**참고**  
로컬 리포지토리를 설정할 필요는 없습니다. [2단계: CodeCommit 리포지토리에 샘플 코드 추가](#codecommit-add-code)에 설명된 대로 콘솔을 사용하여 파일을 업로드할 수도 있습니다.

1. 콘솔에서 새 리포지토리를 연 상태에서 페이지 오른쪽 상단의 **URL 복제**를 선택한 후 **Clone SSH(SSH 복제)**를 선택합니다. Git 리포지토리를 복제할 주소는 클립보드에 복사됩니다.

1. 터미널 또는 명령줄에서 로컬 리포지토리를 저장하고 싶은 로컬 디렉터리로 이동합니다. 이 자습서에서는 `/tmp`를 사용합니다.

1. 다음 명령을 실행하여 리포지토리를 복제하여 SSH 주소를 앞 단계에서 복사한 주소로 교체합니다. 이 명령을 통해 `MyDemoRepo`라는 디렉터리가 생성됩니다. 이 디렉터리에 샘플 애플리케이션을 복사합니다.

   ```
   git clone ssh://git-codecommit.us-west-2.amazonaws.com/v1/repos/MyDemoRepo
   ```

## 2단계: CodeCommit 리포지토리에 샘플 코드 추가
<a name="codecommit-add-code"></a>

이 단계에는 CodeDeploy 예제 연습을 위해 생성했던 샘플 애플리케이션용 코드를 다운로드하고 CodeCommit 리포지토리에 추가합니다.



1. 그런 다음 샘플을 다운로드하여 로컬 컴퓨터의 폴더나 디렉토리에 저장합니다.

   1. 다음 중 하나를 선택합니다. Linux 인스턴스에 대해 이 자습서의 단계를 수행하려는 경우 `SampleApp_Linux.zip`을 선택합니다.
      + CodeDeploy를 사용하여 Amazon Linux 인스턴스에 배포하려는 경우 여기에서 샘플 애플리케이션을 다운로드하세요. [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip)
      + CodeDeploy를 사용하여 Windows Server 인스턴스에 배포하려는 경우 여기에서 샘플 애플리케이션을 다운로드하세요. [SampleApp\$1Windows.zip](samples/SampleApp_Windows.zip)

      샘플 애플리케이션에는 CodeDeploy로 배포하기 위한 다음 파일이 포함되어 있습니다.
      + `appspec.yml` – 애플리케이션 사양 파일(AppSpec file)은 CodeDeploy에서 배포를 관리하는 데 사용하는 [YAML](http://www.yaml.org) 형식의 파일입니다. AppSpec 파일에 대한 자세한 내용은 *AWS CodeDeploy 사용 설명서*의 [CodeDeploy AppSpec 파일 참조](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html)를 참조하세요.
      + `index.html` – 인덱스 파일에는 배포된 샘플 애플리케이션의 홈 페이지가 포함되어 있습니다.
      + `LICENSE.txt` – 라이선스 파일에는 샘플 애플리케이션에 대한 라이선스 정보가 포함되어 있습니다.
      + 스크립트용 파일 - 샘플 애플리케이션은 스크립트를 사용하여 인스턴스의 위치에 텍스트 파일을 씁니다. 여러 CodeDeploy의 배포 수명 주기 이벤트 각각에 대해 하나의 파일이 작성됩니다.
        + (Linux 샘플만 해당) `scripts` 폴더 - 이 폴더에는 종속성을 설치하고 자동 배포를 위한 샘플 애플리케이션을 시작 및 중지하기 위한 `install_dependencies`, `start_server`, `stop_server`와 같은 쉘 스크립트가 포함되어 있습니다.
        + (Windows 샘플만 해당) `before-install.bat` – 이것은 `BeforeInstall` 배포 수명 주기 이벤트의 배치 스크립트로, 이 샘플의 이전 배포 중 기록된 이전 파일을 제거하기 위해 실행되고 인스턴스에 새 파일을 기록할 위치를 만듭니다.

   1. 압축된 파일을 다운로드합니다.

1. 앞서 생성한 로컬 디렉터리에 [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip)에 있는 파일의 압축을 풉니다(예: `/tmp/MyDemoRepo` 또는 `c:\temp\MyDemoRepo`).

   파일을 로컬 리포지토리에 바로 배치해야 합니다. `SampleApp_Linux` 폴더를 포함하면 안 됩니다. 로컬 Linux, macOS 또는 Unix 머신에 다음과 같이 디렉터리 및 파일 계층 구조가 나타나야 합니다.

   ```
   /tmp
      └-- MyDemoRepo
          │-- appspec.yml
          │-- index.html
          │-- LICENSE.txt
          └-- scripts
              │-- install_dependencies
              │-- start_server
              └-- stop_server
   ```

1. 리포지토리에 파일을 업로드하려면 다음 방법 중 하나를 사용합니다.

   1. CodeCommit 콘솔을 사용하여 파일을 업로드하려면 다음과 같이 합니다.

      1. CodeCommit 콘솔을 열고 **리포지토리** 목록에서 해당 리포지토리를 선택합니다.

      1. **파일 추가**를 선택한 후 **파일 업로드**를 선택합니다.

      1. **파일 선택**을 선택한 다음 파일을 찾습니다. 폴더 아래에 파일을 추가하려면 **파일 생성**을 선택한 다음 폴더 이름을 파일 이름과 함께 입력합니다(예: `scripts/install_dependencies`). 파일 내용을 새 파일에 붙여 넣습니다.

         사용자 이름과 이메일 주소를 입력하여 변경 사항을 커밋합니다.

         **변경 사항 커밋**을 선택합니다.

      1. 각 파일에 대해 이 단계를 반복합니다.

         리포지토리 콘텐츠는 다음과 같아야 합니다.

         ```
                │-- appspec.yml
                │-- index.html
                │-- LICENSE.txt
                └-- scripts
                    │-- install_dependencies
                    │-- start_server
                    └-- stop_server
         ```

   1. git 명령을 사용하여 파일을 업로드하려면 

      1. 디렉터리를 로컬 리포지토리로 변경합니다.

         ```
         (For Linux, macOS, or Unix) cd /tmp/MyDemoRepo
         (For Windows) cd c:\temp\MyDemoRepo
         ```

      1. 다음 명령을 실행하여 모든 파일을 한 번에 스테이징합니다.

         ```
         git add -A
         ```

      1. 다음 명령을 실행하여 커밋 메시지와 함께 파일을 커밋합니다.

         ```
         git commit -m "Add sample application files"
         ```

      1. 다음 명령을 실행하여 로컬 리포지토리의 파일을 CodeCommit 리포지토리에 푸시합니다.

         ```
         git push
         ```

1. 다운로드하여 로컬 리포지토리에 추가한 파일이 이제 CodeCommit `MyDemoRepo` 리포지토리의 `main` 브랜치에 추가되었으며 파이프라인에 이를 포함할 수 있습니다.

## 3단계: Amazon EC2 Linux 인스턴스 생성 및 CodeDeploy 에이전트 설치
<a name="codecommit-create-deployment"></a>

이 단계에서는 샘플 애플리케이션이 배포되는 Amazon EC2 인스턴스를 생성합니다. 이 프로세스의 일부로 인스턴스에 CodeDeploy 에이전트를 설치하고 관리할 수 있는 인스턴스 역할을 생성합니다. CodeDeploy 에이전트는 인스턴스를 CodeDeploy 배포에서 사용할 수 있게 해주는 소프트웨어 패키지입니다. 또한 CodeDeploy 에이전트가 애플리케이션을 배포하는 데 사용하는 파일을 인스턴스가 가져오도록 허용하고 SSM에서 인스턴스를 관리할 수 있도록 허용하는 정책을 첨부합니다.

**인스턴스 역할을 생성하려면**

1. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)에서 IAM 콘솔을 엽니다.

1. 콘솔 대시보드에서 **역할**을 선택합니다.

1. **역할 생성**을 선택합니다.

1. **신뢰할 수 있는 유형의 엔터티 선택**에서 **AWS 서비스**를 선택합니다. **사용 사례 선택**에서 **EC2**를 선택합니다. **Select your use case(사용 사례 선택)** 아래에서 **EC2**를 선택합니다. **다음: 권한**을 선택합니다.

1. 검색하여 **`AmazonEC2RoleforAWSCodeDeploy`**라는 정책을 선택합니다.

1. 검색하여 **`AmazonSSMManagedInstanceCore`**라는 정책을 선택합니다. **다음: 태그**를 선택합니다.

1. **다음: 검토**를 선택합니다. 역할의 이름을 입력합니다(예: **EC2InstanceRole**).
**참고**  
다음 단계를 위해 역할 이름을 적어 둡니다. 인스턴스를 생성할 때 이 역할을 선택합니다.

   **역할 생성**을 선택합니다.

**인스턴스 시작**

1. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)에서 Amazon EC2 콘솔을 엽니다.

1. 측면 탐색에서 **인스턴스**를 선택하고 페이지 상단에서 **인스턴스 시작**을 선택합니다.

1. **이름**에 **MyCodePipelineDemo**를 입력합니다. 그러면 인스턴스에 **Name**의 태그 **키**와 **MyCodePipelineDemo**의 태그 **값**이 할당됩니다. 나중에 샘플 애플리케이션을 이 인스턴스에 배포하는 CodeDeploy 애플리케이션을 생성합니다. CodeDeploy는 태그를 기반으로 배포할 인스턴스를 선택합니다.

1. **애플리케이션 및 OS 이미지(Amazon 머신 이미지)**에서 AWS 로고가 있는 **Amazon Linux** AMI 옵션을 찾아 선택했는지 확인합니다. (이 AMI는 Amazon Linux 2 AMI(HVM)로 기술되며 "프리 티어 가능"이라는 레이블이 지정되어 있습니다.)

1. **인스턴스 유형**에서 인스턴스의 하드웨어 구성으로 사용할 프리 티어 가능 `t2.micro` 유형을 선택합니다.

1. **키 페어(로그인)**에서 키 페어를 선택하거나 새로 생성합니다.

   **키 페어 없이 계속**을 선택할 수도 있습니다.
**참고**  
이 자습서의 목적상 키 페어 없이 진행할 수 있습니다. SSH를 사용하여 인스턴스에 연결하려면 키 페어를 생성하거나 사용합니다.

1. **네트워크 설정**에서 다음을 수행합니다.

   **퍼블릭 IP 자동 할당**에서 상태가 **활성화**인지 확인합니다.

   보안 그룹 추가를 선택하고, **HTTP**를 선택한 다음, **소스 유형**에서 **내 IP**를 선택합니다.

1. **Advanced details**(고급 세부 정보)를 확장합니다. **IAM 인스턴스 프로파일**에서 이전 절차에서 생성한 IAM 역할을 선택합니다(예: **EC2InstanceRole**).

1. **요약**에서 **인스턴스 수**에 `1`를 입력합니다.

1. **인스턴스 시작**을 선택합니다.

1. [**Instances**] 페이지에서 시작 상태를 볼 수 있습니다. 인스턴스를 시작할 때 초기 상태는 `pending`입니다. 인스턴스가 시작된 후에는 상태가 `running`으로 바뀌고 퍼블릭 DNS 이름을 받습니다. [**Public DNS**] 열이 표시되지 않으면 [**Show/Hide**] 아이콘을 선택하고 [**Public DNS**]를 선택합니다.

## 4단계: CodeDeploy에서 애플리케이션 생성
<a name="codecommit-create-codedeploy-app"></a>

CodeDeploy에서 [애플리케이션](https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html)은 배포하고자 하는 소프트웨어 애플리케이션이 포함된 리소스입니다.** 나중에 이 애플리케이션을 CodePipeline과 함께 사용해 Amazon EC2 인스턴스에 대한 샘플 애플리케이션 배포를 자동화할 수 있습니다.

먼저 CodeDeploy가 배포를 수행하도록 허용하는 역할을 생성합니다. 그런 다음 CodeDeploy 애플리케이션을 만듭니다.

**CodeDeploy 서비스 역할을 만들려면**

1. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)에서 IAM 콘솔을 엽니다.

1. 콘솔 대시보드에서 **역할**을 선택합니다.

1. **역할 생성**을 선택합니다.

1. **신뢰할 수 있는 엔터티 선택**에서 **AWS 서비스**를 선택합니다. **사용 사례**에서 **CodeDeploy**를 선택합니다. 나열된 옵션에서 **CodeDeploy**를 선택합니다. **다음**을 선택합니다. `AWSCodeDeployRole` 관리형 정책이 역할에 연결됩니다.

1. **다음**을 선택합니다.

1. 역할 이름(예: **CodeDeployRole**)을 입력한 후 **Create role(역할 생성)**을 선택합니다.

**CodeDeploy에서 애플리케이션을 만들려면**

1. [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy)에서 CodeDeploy 콘솔을 엽니다.

1. **애플리케이션** 페이지가 나타나지 않으면 메뉴에서 **애플리케이션**을 선택합니다.

1. **애플리케이션 생성**을 선택합니다.

1. **애플리케이션 이름**에 **MyDemoApplication**을 입력합니다.

1. **Compute Platform(컴퓨팅 플랫폼)**에서 **EC2/On-premises(EC2/온프레미스)**를 선택합니다.

1. **애플리케이션 생성**을 선택합니다.

**CodeDeploy에서 배포 그룹을 생성하려면**

[https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-groups.html](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-groups.html)은 배포할 인스턴스, 배포 속도와 같은 배포 관련 설정을 정의하는 리소스입니다.

1. 애플리케이션이 표시되는 페이지에서 **Create deployment group(배포 그룹 생성)**을 선택합니다.

1. **Deployment group name(배포 그룹 이름)**에 **MyDemoDeploymentGroup**을 입력합니다.

1. **서비스 역할**에서 앞서 생성한 서비스 역할의 ARN을 선택합니다(예: **`arn:aws:iam::account_ID:role/CodeDeployRole`**).

1. **배포 유형** 아래에서 **인 플레이스**를 선택합니다.

1. [**Environment configuration**]에서 [**Amazon EC2 Instances**] 탭을 선택합니다. **키** 필드에 **Name**을 입력합니다. **값** 필드에 인스턴스에 태그를 지정하는 데 사용한 이름을 입력합니다(예: **MyCodePipelineDemo**).

1. ** AWS Systems Manager를 사용한 에이전트 구성**에서 **지금 및 일정 업데이트를** 선택합니다. 그러면 인스턴스에 에이전트가 설치됩니다. Linux 인스턴스는 이미 SSM 에이전트로 구성되어 있으며 이제 CodeDeploy 에이전트로 업데이트됩니다.

1. **Deployment configuration(배포 구성)**에서 `CodeDeployDefault.OneAtaTime`을 선택합니다.

1. **로드 밸런서**에서 **로드 밸런싱 활성화**가 선택되지 않았는지 확인합니다. 이 예에서는 로드 밸런서를 설정하거나 대상 그룹을 선택할 필요가 없습니다.

1. [**Create deployment group**]을 선택합니다.

## 5단계: CodePipeline에서 첫 번째 파이프라인 생성
<a name="codecommit-create-pipeline"></a>

이제 첫 번째 파이프라인을 생성하고 실행할 준비가 되었습니다. 이 단계에서는 코드가 CodeCommit 리포지토리로 푸시될 때 자동으로 실행되는 파이프라인을 생성합니다.

**CodePipeline 파이프라인을 생성하려면**

1. 에 로그인 AWS Management Console 하고 [http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) CodePipeline 콘솔을 엽니다.

   [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔을 엽니다.

1. [**Welcome**] 페이지, [**Getting started**] 페이지 또는 [**Pipelines**] 페이지에서 **Create pipeline(파이프라인 생성)**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 **MyFirstPipeline**을 입력합니다.

1. CodePipeline은 특성과 가격이 다른 V1 및 V2 유형 파이프라인을 제공합니다. V2 유형은 콘솔에서 선택할 수 있는 유일한 유형입니다. 자세한 내용은 [파이프라인 유형](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)을 참조하세요. CodePipeline에 대한 요금 정보는 [요금](https://aws.amazon.com/codepipeline/pricing/)을 참조하세요.

1. **서비스 역할**에서 **새 서비스 역할**을 선택하여CodePipeline이 IAM에 서비스 역할을 생성하도록 허용합니다.

1. [**Advanced settings**]의 설정은 기본값 그대로 두고, [**Next**]를 선택합니다.

1. **3단계: 소스 스테이지 추가**의 **소스 공급자**에서 **CodeCommit**을 선택합니다. **리포지토리 이름**에서 [1단계: CodeCommit 리포지토리 생성](#codecommit-create-repository)에서 생성한 CodeCommit 리포지토리의 이름을 선택합니다. **브랜치 이름**에서 `main`를 선택하고 **다음 단계**를 선택합니다.

   리포지토리 이름과 브랜치를 선택하면 이 파이프라인에 대해 생성될 Amazon CloudWatch Events 규칙을 보여 주는 메시지가 표시됩니다.

   [**Change detection options**] 아래에서 기본값을 그대로 둡니다. 그러면 CodePipeline이 Amazon CloudWatch Events를 사용하여 소스 리포지토리의 변경을 감지할 수 있습니다.

   **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가**에서 **빌드 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다. **다음**을 선택합니다.
**참고**  
이 자습서에서는 빌드 서비스가 필요 없는 코드를 배포하므로 이 단계는 건너뛸 수 있습니다. 그러나 소스 코드를 인스턴스에 배포하기 전에 빌드해야 하는 경우 이 단계에서 [CodeBuild](https://aws.amazon.com/codebuild/)를 구성할 수 있습니다.

1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **6단계: 배포 단계 추가**의 **배포 공급자**에서 **CodeDeploy**를 선택합니다. **애플리케이션 이름**에서 **MyDemoApplication**을 선택합니다. **배포 그룹**에서 **MyDemoDeploymentGroup**을 선택하고 **다음 단계**를 선택합니다.

1. **7단계: 검토**에서 정보를 검토한 다음 **파이프라인 생성을** 선택합니다.

1. 파이프라인은 생성된 후 실행되기 시작하여 CodeCommit 리포지토리에서 코드를 다운로드하고 EC2 인스턴스에 CodeDeploy 배포를 생성합니다. CodePipeline 샘플이 CodeDeploy 배포의 Amazon EC2 인스턴스에 웹 페이지를 배포하므로 진행 사항과 성공 및 실패 메시지를 볼 수 있습니다.  
![\[CodePipeline 콘솔에서 실행되기 시작하는 파이프라인 보기\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/codepipeline-firstpipeline-codecommit-pol.png)

축하합니다\$1 방금 CodePipeline에서 간단한 파이프라인을 생성했습니다.

다음으로, 결과를 확인합니다.

**파이프라인이 성공적으로 실행되었는지 확인하려면**

1. 파이프라인의 초기 진행 상황을 확인합니다. 각 단계의 상태는 [**No executions yet**]에서 [**In Progress**]로 바뀌며, 다시 [**Succeeded**]나 [**Failed**] 중 하나로 바뀝니다. 파이프라인은 몇 분 내로 첫 번째 실행을 완료해야 합니다.

1. 파이프라인 상태가 **성공함**으로 표시되면 **배포** 단계의 상태 영역에서 **CodeDeploy**를 선택합니다. 그러면 CodeDeploy 콘솔이 열립니다. **Succeeded**가 표시되지 않는 경우 [CodePipeline 문제 해결](troubleshooting.md)를 참조하십시오.

1.  **배포** 탭에서 배포 ID를 선택합니다. 배포 페이지의 **배포 수명 주기 이벤트**에서 인스턴스 ID를 선택합니다. EC2 콘솔이 열립니다.

1. **설명** 탭의 **퍼블릭 DNS**에서 주소(예: `ec2-192-0-2-1.us-west-2.compute.amazonaws.com`)를 복사하여 웹 브라우저의 주소 표시줄에 붙여 넣습니다.

   웹페이지에 CodeCommit 리포지토리에 다운로드하고 푸시한 샘플 애플리케이션이 표시됩니다.

단계, 작업, 파이프라인의 작동 방식에 대한 자세한 내용은 [CodePipeline 개념](concepts.md) 단원을 참조하십시오.

## 6단계: CodeCommit 리포지토리의 코드 수정
<a name="codecommit-push-code"></a>

파이프라인은 CodeCommit 리포지토리에 코드 변경이 이루어질 때마다 실행되도록 구성됩니다. 이 단계에서는 CodeCommit 리포지토리의 샘플 CodeDeploy 애플리케이션의 일부인 HTML 파일을 변경합니다. 이러한 변경 사항을 푸시하면 파이프라인이 다시 실행되고 변경 사항이 앞서 액세스한 웹 주소에 표시됩니다.

1. 디렉터리를 로컬 리포지토리로 변경합니다.

   ```
   (For Linux, macOS, or Unix) cd /tmp/MyDemoRepo
   (For Windows) cd c:\temp\MyDemoRepo
   ```

1. 텍스트 편집기를 사용하여 `index.html` 파일을 수정합니다.

   ```
   (For Linux or Unix)gedit index.html
   (For OS X)open –e index.html
   (For Windows)notepad index.html
   ```

1. `index.html` 파일의 콘텐츠를 수정하여 웹 페이지의 배경 색과 텍스트 일부를 변경한 다음, 파일을 저장합니다.

   ```
   <!DOCTYPE html>
   <html>
   <head>
     <title>Updated Sample Deployment</title>
     <style>
       body {
         color: #000000;
         background-color: #CCFFCC;
         font-family: Arial, sans-serif;  
         font-size:14px;
       }
           
       h1 {
         font-size: 250%;
         font-weight: normal;
         margin-bottom: 0;
       }
       
       h2 {
         font-size: 175%;
         font-weight: normal;
         margin-bottom: 0;
       }
     </style>
   </head>
   <body>
     <div align="center"><h1>Updated Sample Deployment</h1></div>
     <div align="center"><h2>This application was updated using CodePipeline, CodeCommit, and CodeDeploy.</h2></div>
     <div align="center">
       <p>Learn more:</p> 
       <p><a href="https://docs.aws.amazon.com/codepipeline/latest/userguide/">CodePipeline User Guide</a></p>
       <p><a href="https://docs.aws.amazon.com/codecommit/latest/userguide/">CodeCommit User Guide</a></p>
       <p><a href="https://docs.aws.amazon.com/codedeploy/latest/userguide/">CodeDeploy User Guide</a></p>
     </div>
   </body>
   </html>
   ```

1. 다음 명령을 실행하여 변경 사항을 커밋하고 CodeCommit 리포지토리에 푸시하는 작업을 한 번에 수행합니다.

   ```
   git commit -am "Updated sample application files"
   ```

   ```
   git push
   ```

**파이프라인이 성공적으로 실행되었는지 확인하려면**

1. 파이프라인의 초기 진행 상황을 확인합니다. 각 단계의 상태는 [**No executions yet**]에서 [**In Progress**]로 바뀌며, 다시 [**Succeeded**]나 [**Failed**] 중 하나로 바뀝니다. 파이프라인 실행은 몇 분 내로 완료되어야 합니다.

1. 작업 상태에 **Succeeded**가 표시된 후에는 브라우저에서 앞서 액세스한 데모 페이지를 새로 고침하십시오.

   업데이트된 웹 페이지가 표시됩니다.

## 7단계: 리소스 정리
<a name="codecommit-clean-up"></a>

이 설명서에 있는 다른 자습서를 위해 이 자습서에서 생성한 리소스 중 일부를 사용할 수 있습니다. 예를 들어 CodeDeploy 애플리케이션 및 배포를 재사용할 수 있습니다. 하지만 이 자습서와 다른 자습서를 완료한 후에는 사용한 파이프라인과 리소스를 삭제해야 이 리소스를 계속 사용할 경우 부과되는 요금을 피할 수 있습니다. 먼저 파이프라인을 삭제하고 CodeDeploy 애플리케이션과 그에 연결된 Amazon EC2 인스턴스, 끝으로 CodeCommit 리포지토리를 삭제합니다.

**이 자습서에서 사용한 리소스를 정리하려면**

1. CodePipeline 리소스를 정리하려면 [AWS CodePipeline에서 파이프라인 삭제](pipelines-delete.md) 단원의 지침을 따릅니다.

1. CodeDeploy 리소스를 정리하려면 [배포 연습 리소스 정리](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-simple-s3alkthrough.html#tutorials-simple-s3alkthrough-clean-up) 단원의 지침을 따릅니다.

1. CodeCommit 리포지토리를 삭제하려면 [CodeCommit 리포지토리 삭제](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-delete-repository.html)의 지침을 따릅니다.

## 8단계: 참조 자료
<a name="codecommit-optional-tasks"></a>

CodePipeline이 어떻게 작동하는지 자세히 알아보세요.
+ 단계, 작업, 파이프라인의 작동 방식에 대한 자세한 내용은 [CodePipeline 개념](concepts.md) 단원을 참조하십시오.
+ CodePipeline을 사용해 수행할 수 있는 작업에 대한 자세한 내용은 [CodePipeline 작업 유형과의 통합](integrations-action-type.md)을 참조하세요.
+ 좀 더 수준이 높은 자습서인 [자습서: 4단계 파이프라인 생성](tutorials-four-stage-pipeline.md)를 사용해 보십시오. 이 자습서에서는 코드를 배포 전에 빌드하는 단계가 포함된 다단계 파이프라인을 생성합니다.

# 자습서: 4단계 파이프라인 생성
<a name="tutorials-four-stage-pipeline"></a>

이제 [자습서: 간단한 파이프라인 생성(S3 버킷)](tutorials-simple-s3.md) 또는 [자습서: 간단한 파이프라인 생성(CodeCommit 리포지토리)](tutorials-simple-codecommit.md)에서 첫 번째 파이프라인을 생성했으므로 더 복잡한 파이프라인 생성을 시작할 수 있습니다. 이 자습서에서는 소스에 대한 GitHub 리포지토리, 프로젝트를 빌드하기 위한 Jenkins 빌드 서버, 빌드된 코드를 스테이징 서버에 배포하기 위한 CodeDeploy 애플리케이션을 사용하는 4단계 파이프라인의 생성에 대해 안내합니다. 다음 다이어그램은 초기 3단계 파이프라인을 보여줍니다.

![\[소스 작업이 포함된 소스 단계, Jenkins 작업이 포함된 빌드 단계, 배포 작업이 포함된 배포 단계를 보여주는 다이어그램입니다.\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/flow-codepipeline-codecommit-jenkins.png)


파이프라인이 생성된 후 Jenkins도 사용하여 코드를 테스트하는 테스트 작업으로 단계를 추가하도록 이 파이프라인을 편집합니다.

이 파이프라인을 생성하기 전에 필요한 리소스를 구성해야 합니다. 예를 들어 소스 코드에 대한 GitHub 리포지토리를 사용할 경우 리포지토리를 파이프라인에 추가하기 전에 생성해야 합니다. 설정의 일부로 이 자습서에서는 데모용으로 EC2 인스턴스에서 Jenkins의 설정에 대해 안내합니다.

**중요**  
이 절차에서 파이프라인에 추가하는 많은 작업에는 파이프라인을 생성하기 전에 생성해야 하는 AWS 리소스가 포함됩니다. 소스 작업에 대한 AWS 리소스는 항상 파이프라인을 생성하는 리전과 동일한 AWS 리전에서 생성해야 합니다. 예를 들어, 미국 동부(오하이오) 리전에서 파이프라인을 생성하는 경우, CodeCommit 리포지토리도 미국 동부(오하이오) 리전에 있어야 합니다.  
파이프라인을 생성할 때 교차 리전 작업을 추가할 수 있습니다. 교차 리전 작업에 대한 AWS 리소스는 작업을 실행하려는 리전과 동일한 AWS 리전에 있어야 합니다. 자세한 내용은 [CodePipeline에 교차 리전 작업 추가](actions-create-cross-region.md) 단원을 참조하십시오.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

이 자습서를 시작하기 전에 [CodePipeline 시작하기](getting-started-codepipeline.md)의 일반적인 사전 조건을 이미 완료했어야 합니다.

**Topics**
+ [1단계: 사전 조건 완료](#tutorials-four-stage-pipeline-prerequisites)
+ [2단계: CodePipeline에서 파이프라인 생성](#tutorials-four-stage-pipeline-pipeline-create)
+ [3단계: 파이프라인에 다른 단계 추가](#tutorials-four-stage-pipeline-add-stage)
+ [4단계: 리소스 정리](#tutorials-four-stage-pipeline-clean-up)

## 1단계: 사전 조건 완료
<a name="tutorials-four-stage-pipeline-prerequisites"></a>

를 Jenkins와 통합하려면 CodePipeline과 함께 사용하려는 모든 Jenkins 인스턴스에 Jenkins용 CodePipeline 플러그인을 설치해야 AWS CodePipeline 합니다. 또한 Jenkins 프로젝트와 CodePipeline 간의 권한을 위해 사용하도록 전용 IAM 사용자 또는 역할을 구성해야 합니다. Jenkins와 CodePipeline을 통합하는 가장 간단한 방법은 Jenkins 통합을 위해 생성한 IAM 인스턴스 역할을 사용하는 EC2 인스턴스에 Jenkins를 설치하는 것입니다. Jenkins 작업에 대한 파이프라인의 링크가 성공적으로 연결되려면 Jenkins 프로젝트에서 사용된 포트에 대한 인바운드 연결을 허용하도록 서버 또는 EC2 인스턴스에 프록시 및 방화벽 설정을 구성해야 합니다. 해당 포트(예: HTTPS 연결만 사용하기 위해 Jenkins를 보호한 경우 443 및 8443 또는 HTTP 연결을 허용한 경우 80 및 8080)에 대한 연결을 허용하기 전에 액세스 제어를 적용하고 사용자를 인증하도록 Jenkins를 구성했는지 확인합니다. 자세한 내용은 [Jenkins 보호](https://wiki.jenkins.io/display/JENKINS/Securing+Jenkins)를 참조하십시오.

**참고**  
이 자습서에서는 코드 샘플을 사용하고 샘플을 Haml에서 HTML로 변환하는 빌드 단계를 구성합니다. [GitHub 리포지토리에 샘플 복사 또는 복제](#tutorials-four-stage-pipeline-prerequisites-github)의 단계에 따라 GitHub 리포지토리에서 오픈 소스 샘플 코드를 다운로드할 수 있습니다. .zip 파일뿐만 아니라 GitHub 리포지토리의 전체 샘플도 필요합니다.  
이 자습서는 다음 사항도 가정합니다.  
Jenkins를 설치 및 관리하고 Jenkins 프로젝트를 생성하는 데 익숙합니다.
Jenkins 프로젝트를 호스팅하는 동일한 컴퓨터나 인스턴스에 Rake 및 Haml gem for Ruby를 설치했습니다.
Rake 명령을 터미널이나 명령줄에서 실행할 수 있도록 필요한 시스템 환경 변수를 설정했습니다(예: Windows 시스템의 경우 Rake를 설치한 디렉터리를 포함하도록 PATH 변수 수정).

**Topics**
+ [GitHub 리포지토리에 샘플 복사 또는 복제](#tutorials-four-stage-pipeline-prerequisites-github)
+ [Jenkins 통합에 사용할 IAM 역할 생성](#tutorials-four-stage-pipeline-prerequisites-jenkins-iam-role)
+ [Jenkins 및 Jenkins용 CodePipeline 플러그인 설치 및 구성](#tutorials-four-stage-pipeline-prerequisites-jenkins-configure)

### GitHub 리포지토리에 샘플 복사 또는 복제
<a name="tutorials-four-stage-pipeline-prerequisites-github"></a>

**샘플을 복제하고 GitHub 리포지토리에 푸시하려면**

1. GitHub 리포지토리로부터 샘플 코드를 다운로드하거나 로컬 컴퓨터에 리포지토리를 복제합니다. 다음과 같은 두 가지 샘플 패키지가 있습니다.
   + 샘플을 Amazon Linux, RHEL 또는 Ubuntu Server 인스턴스에 배포하려는 경우 [codepipeline-jenkins-aws-codedeploy\$1linux.zip](https://github.com/awslabs/aws-codepipeline-jenkins-aws-codedeploy_linux)를 선택하세요.
   + 샘플을 Windows Server 인스턴스에 배포하려는 경우 [CodePipeline-Jenkins-AWSCodeDeploy\$1Windows.zip](https://github.com/awslabs/AWSCodePipeline-Jenkins-AWSCodeDeploy_windows)를 선택하세요.

1. 리포지토리에서, [**Fork**]를 선택하여 샘플 리포지토리를 Github 계정의 리포지토리에 복제합니다. 자세한 내용은 [GitHub 문서](https://help.github.com/articles/create-a-repo/)를 참조하십시오.

### Jenkins 통합에 사용할 IAM 역할 생성
<a name="tutorials-four-stage-pipeline-prerequisites-jenkins-iam-role"></a>

EC2 인스턴스를 시작하여 Jenkins 서버를 호스팅하고 IAM 역할을 사용하여 CodePipeline과 상호 작용하는 데 필요한 권한을 인스턴스에 부여하는 것이 좋습니다.

1. 에 로그인 AWS Management Console 하고 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) IAM 콘솔을 엽니다.

1. IAM 콘솔의 탐색 창에서 **역할**을 선택한 후 **역할 생성**을 선택합니다.

1. **신뢰할 수 있는 유형의 엔터티 선택**에서 **AWS 서비스**(을)를 선택합니다. **Choose the service that will use this role(이 역할을 사용할 서비스 선택)** 아래에서 **EC2**를 선택합니다. **Select your use case(사용 사례 선택)** 아래에서 **EC2**를 선택합니다.

1. **다음: 권한**을 선택합니다. **Attach permissions policies(권한 정책 연결)** 페이지에서 `AWSCodePipelineCustomActionAccess` 관리형 정책을 선택한 다음, **Next: Tags(다음: 태그)**를 선택합니다. **다음: 검토**를 선택합니다.

1. **검토** 페이지의 **역할 이름**에 Jenkins 통합을 위해 특별히 생성할 역할 이름(예: *JenkinsAccess*)을 입력한 다음, **역할 생성**을 선택합니다.

Jenkins를 설치하는 EC2 인스턴스를 생성하면 **3단계: 인스턴스 세부 정보 구성**에서 인스턴스 역할(예: *JenkinsAccess*)을 선택해야 합니다.

인스턴스 역할 및 Amazon EC2에 대한 자세한 내용은 [Amazon EC2의 IAM 역할](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html), [IAM 역할을 사용하여 Amazon EC2 인스턴스에서 실행 중인 애플리케이션에 대한 권한 부여](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-usingrole-ec2instance.html), [AWS 서비스에 대한 권한을 위임할 역할 생성](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-creatingrole-service.html)을 참조하세요.

### Jenkins 및 Jenkins용 CodePipeline 플러그인 설치 및 구성
<a name="tutorials-four-stage-pipeline-prerequisites-jenkins-configure"></a>

**Jenkins 및 Jenkins용 CodePipeline 플러그인을 설치하려면**

1. Jenkins를 설치할 EC2 인스턴스를 생성하고 **3단계: 인스턴스 세부 정보 구성**에서 방금 생성한 인스턴스 역할(예: *JenkinsAccess*)을 선택해야 합니다. EC2 인스턴스 생성에 대한 자세한 내용은 Amazon EC2 사용 설명서의 [Amazon EC2 인스턴스 시작하기](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-instance_linux.html)를 참조하세요.**
**참고**  
사용할 Jenkins 리소스가 이미 있는 경우, 이 리소스를 사용할 수 있지만, 특정 IAM 사용자를 생성하고, `AWSCodePipelineCustomActionAccess` 관리형 정책을 이 사용자에게 적용한 다음, Jenkins 리소스의 해당 사용자에 대한 액세스 자격 증명을 구성하고 사용해야 합니다. Jenkins UI를 사용하여 자격 증명을 공급하려면 HTTPS만 허용하도록 Jenkins를 구성합니다. 자세한 내용은 [CodePipeline 문제 해결](troubleshooting.md) 단원을 참조하십시오.

1. EC2 인스턴스에 Jenkins를 설치합니다. 자세한 내용은 [Jenkins 설치](https://www.jenkins.io/doc/book/installing/linux/) 및 [Jenkins 시작 및 액세스](https://wiki.jenkins.io/JENKINS/Starting-and-Accessing-Jenkins.html)와 [CodePipeline과 제품 및 서비스 통합](integrations.md)의 [details of integration with Jenkins](integrations-action-type.md#JenkinsInt_2)에 대한 Jenkins 설명서를 참조하십시오.

1. Jenkins를 시작하고 홈 페이지에서 [**Manage Jenkins**]를 선택합니다.

1. [**Manage Jenkins**] 페이지에서 [**Manage Plugins**]를 선택합니다.

1. [**Available**] 탭을 선택하고, [**Filter**] 검색 상자에서, **AWS CodePipeline**을 입력합니다. 목록에서 **Jenkins용 CodePipeline 플러그인**을 선택하고 **지금 다운로드 및 다시 시작 후 설치**를 선택합니다.

1. [**Installing Plugins/Upgrades**] 페이지에서 [**Restart Jenkins when installation is complete and no jobs are running**]을 선택합니다.

1. [**Back to Dashboard**]를 선택합니다.

1. 기본 페이지에서 [**New Item**]을 선택합니다.

1. [**Item Name**]에 Jenkins 프로젝트의 이름을 입력합니다(예: *MyDemoProject*). [**Freestyle project**]를 선택한 다음, [**OK**]를 선택합니다.
**참고**  
프로젝트 이름이 CodePipeline의 요구 사항을 충족해야 합니다. 자세한 내용은 [AWS CodePipeline의 할당량](limits.md) 단원을 참조하십시오.

1. 프로젝트의 구성 페이지에서 [**Execute concurrent builds if necessary**] 확인란을 선택합니다. [**Source Code Management**]에서, [**AWS CodePipeline**]를 선택합니다. EC2 인스턴스에 Jenkins를 설치하고 CodePipeline과 Jenkins 간의 통합을 위해 생성한 IAM 사용자의 프로필 AWS CLI 로를 구성한 경우 다른 모든 필드는 비워 둡니다.

1. **고급**을 선택하고, **공급자**에서 CodePipeline에 표시될 작업의 공급자 이름(예: *MyJenkinsProviderName*)을 입력합니다. 이 이름은 고유해야 하며 기억하기 쉬워야 합니다. 이 자습서 후반부에 파이프라인에 빌드 작업을 추가할 때 및 테스트 작업을 추가할 때 이 이름을 사용할 것입니다.
**참고**  
이 작업 이름은 CodePipeline의 작업에 대한 명명 요구사항을 만족해야 합니다. 자세한 내용은 [AWS CodePipeline의 할당량](limits.md) 단원을 참조하십시오.

1. [**Build Triggers**]에서 모든 상자의 선택을 취소한 다음 [**Poll SCM**]을 선택합니다. [**Schedule**]에서 다음과 같이 5개의 별표를 공백으로 구분하여 입력합니다.

   ```
   * * * * *
   ```

   이렇게 하면 1분마다 CodePipeline이 폴링됩니다.

1. [**Build**]에서 [**Add build step**]을 선택합니다. **쉘 실행**(Amazon Linux, RHEL 또는 Ubuntu Server) **배치 명령 실행**(Windows Server)을 선택하고 다음을 입력합니다.

   ```
   rake
   ```
**참고**  
rake를 실행하는 데 필요한 변수 및 설정을 사용하여 환경을 구성해야 합니다. 그렇지 않으면 빌드가 실패합니다.

1. **빌드 후 작업 추가**를 선택한 다음, **AWS CodePipeline 게시자**를 선택합니다. [**Add**]를 선택한 다음, [**Build Output Locations**]에서 위치를 비워 둡니다. 이 구성이 기본 구성입니다. 이렇게 하면 빌드 프로세스 마지막에 압축된 파일이 생성됩니다.

1. [**Save**]를 선택하여 Jenkins 프로젝트를 저장합니다.

## 2단계: CodePipeline에서 파이프라인 생성
<a name="tutorials-four-stage-pipeline-pipeline-create"></a>

자습서의 이 부분에서는 **Create Pipeline** 마법사를 사용하여 파이프라인을 생성합니다.

**CodePipeline 자동화 릴리스 프로세스 생성 방법**

1. 에 로그인 AWS Management Console 하고 [http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) CodePipeline 콘솔을 엽니다.

1. 필요하면, 리전 선택기를 사용하여 파이프라인 리소스가 위치하는 리전으로 리전을 변경합니다. 예를 들어 이전 자습서에서 `us-east-2`에 리소스를 만든 경우 리전 선택기가 미국 동부(오하이오)로 설정되어야 합니다.

   CodePipeline에 사용할 수 있는 리전과 엔드포인트에 대한 자세한 내용은 [AWS CodePipeline 엔드포인트 및 할당량](https://docs.aws.amazon.com/general/latest/gr/codepipeline.html)을 참조하세요.

1. [**Welcome**] 페이지, [**Getting started**] 페이지 또는 [**Pipelines**] 페이지에서 **Create pipeline(파이프라인 생성)**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택** 페이지의 **파이프라인 이름**에 파이프라인 이름을 입력합니다.

1. CodePipeline은 특성과 가격이 다른 V1 및 V2 유형 파이프라인을 제공합니다. V2 유형은 콘솔에서 선택할 수 있는 유일한 유형입니다. 자세한 내용은 [파이프라인 유형](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)을 참조하세요. CodePipeline에 대한 요금 정보는 [요금](https://aws.amazon.com/codepipeline/pricing/)을 참조하세요.

1. **서비스 역할**에서 **새 서비스 역할**을 선택하여CodePipeline이 IAM에 서비스 역할을 생성하도록 허용합니다.

1. [**Advanced settings**]의 설정은 기본값 그대로 두고, [**Next**]를 선택합니다.

1. **3단계: 소스 스테이지 추가** 페이지의 **소스 공급자**에서 **GitHub**를 선택합니다.

1. **연결**에서 기존 연결을 선택하거나 새로 생성합니다. GitHub 소스 작업에 대한 연결을 만들거나 관리하려면 [GitHub 연결](connections-github.md)을 참조하세요.

1. **4단계: 빌드 스테이지 추가**에서 **Jenkins 추가**를 선택합니다. **공급자 이름**에서 Jenkins용 CodePipeline 플러그인에 제공한 작업 이름(예: *MyJenkinsProviderName*)을 입력합니다. 이 이름은 Jenkins용 CodePipeline 플러그인의 이름과 정확하게 일치해야 합니다. [**Server URL**]에서 Jenkins가 설치된 EC2 인스턴스의 URL을 입력합니다. **프로젝트 이름**에서, Jenkins에서 생성한 프로젝트 이름(예: *MyDemoProject*)을 입력한 다음, **다음**을 선택합니다.

1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **6단계: 배포 단계 추가**에서에서 생성한 CodeDeploy 애플리케이션 및 배포 그룹을 재사용합니다[자습서: 간단한 파이프라인 생성(S3 버킷)](tutorials-simple-s3.md). **배포 공급자**에서 **CodeDeploy**를 선택합니다. **애플리케이션 이름**에 **CodePipelineDemoApplication**을 입력하거나 새로 고침 버튼을 선택한 다음, 목록에서 애플리케이션 이름을 선택합니다. **배포 그룹**에서 **CodePipelineDemoFleet**을 입력하거나, 목록에서 이를 선택한 후 **다음**을 선택합니다.
**참고**  
사용자 고유의 CodeDeploy 리소스를 사용하거나 새로운 리소스를 만들 수 있지만, 추가 비용이 발생할 수 있습니다.

1. **7단계: 검토**에서 정보를 검토한 다음 **파이프라인 생성을** 선택합니다.

1. 파이프라인이 자동으로 시작되고 파이프라인을 통해 샘플이 실행됩니다. 파이프라인이 Haml 샘플을 HTML에 빌드하고 이를 CodeDeploy 배포의 각 Amazon EC2 인스턴스에 웹 페이지로 배포하므로 진행 사항과 성공 및 실패 메시지를 볼 수 있습니다.

## 3단계: 파이프라인에 다른 단계 추가
<a name="tutorials-four-stage-pipeline-add-stage"></a>

이제 테스트 단계를 추가한 다음 샘플에 포함된 Jenkins 테스트를 사용하는 해당 단계에 테스트 작업을 추가하여 웹 페이지에 콘텐츠가 있는지 여부를 확인합니다. 이 테스트는 데모용일 뿐입니다.

**참고**  
파이프라인에 다른 단계를 추가하지 않은 경우 배포 작업의 이전이나 이후에 파이프라인의 스테이징 단계에 테스트 작업을 추가할 수 있습니다.

### 파이프라인에 테스트 단계 추가
<a name="tutorials-four-stage-pipeline-add-stage-console"></a>

**Topics**
+ [인스턴스의 IP 주소 조회](#tutorials-four-stage-pipeline-instance-ip-lookup)
+ [배포 테스트를 위해 Jenkins 프로젝트 생성](#tutorials-four-stage-pipeline-create-jenkins-project)
+ [네 번째 단계 생성](#tutorials-four-stage-pipeline-create-fourth-stage)

#### 인스턴스의 IP 주소 조회
<a name="tutorials-four-stage-pipeline-instance-ip-lookup"></a>

**코드를 배포한 인스턴스의 IP 주소를 확인하려면**

1. 파이프라인 상태가 [**Succeeded**]로 표시되면 스테이징 단계의 상태 영역에서 [**Details**]를 선택합니다.

1. [**Deployment Details**] 섹션의 [**Instance ID**]에서 성공적으로 배포한 인스턴스 중 하나의 인스턴스 ID를 선택합니다.

1. 인스턴스의 IP 주소를 복사합니다(예: *192.168.0.4*). Jenkins 테스트에서 이 IP 주소를 사용할 것입니다.

#### 배포 테스트를 위해 Jenkins 프로젝트 생성
<a name="tutorials-four-stage-pipeline-create-jenkins-project"></a>

**Jenkins 프로젝트를 만들려면**

1. Jenkins를 설치한 인스턴스에서, Jenkins를 열고 기본 페이지에서 [**New Item**]을 선택합니다.

1.  [**Item Name**]에 Jenkins 프로젝트의 이름을 입력합니다(예: *MyTestProject*). [**Freestyle project**]를 선택한 다음, [**OK**]를 선택합니다.
**참고**  
프로젝트 이름이 CodePipeline 요구 사항을 충족해야 합니다. 자세한 내용은 [AWS CodePipeline의 할당량](limits.md) 단원을 참조하십시오.

1. 프로젝트의 구성 페이지에서 [**Execute concurrent builds if necessary**] 확인란을 선택합니다. [**Source Code Management**]에서, [**AWS CodePipeline**]를 선택합니다. EC2 인스턴스에 Jenkins를 설치하고 CodePipeline과 Jenkins 간의 통합을 위해 생성한 IAM 사용자의 프로필 AWS CLI 로를 구성한 경우 다른 모든 필드는 비워 둡니다.
**중요**  
Jenkins 프로젝트를 구성하는 중이고 Amazon EC2 인스턴스에 설치되어 있지 않거나, Windows 운영 체제를 실행 중인 EC2 인스턴스에 설치되어 있는 경우, 프록시 호스트 및 포트 설정에서 요구하는 대로 필드를 채우고, CodePipeline과 Jenkins 간 통합용으로 구성한 IAM 사용자 또는 역할의 자격 증명을 제공합니다.

1. [**Advanced**]를 선택하고, [**Category**]에서 [**Test**]를 선택합니다.

1. [**Provider**]에서, 빌드 프로젝트에 사용한 동일한 이름(예: *MyJenkinsProviderName*)을 입력합니다. 이 이름은 이 자습서의 후반부에서 파이프라인에 테스트 작업을 추가할 때 사용됩니다.
**참고**  
이 이름은 작업에 대한 CodePipeline 명명 요구사항을 만족해야 합니다. 자세한 내용은 [AWS CodePipeline의 할당량](limits.md) 단원을 참조하십시오.

1. [**Build Triggers**]에서 모든 상자의 선택을 취소한 다음 [**Poll SCM**]을 선택합니다. [**Schedule**]에서 다음과 같이 5개의 별표를 공백으로 구분하여 입력합니다.

   ```
   * * * * *
   ```

   이렇게 하면 1분마다 CodePipeline이 폴링됩니다.

1. [**Build**]에서 [**Add build step**]을 선택합니다. Amazon Linux, RHEL 또는 Ubuntu Server 인스턴스에 배포하는 경우 **쉘 실행**을 선택합니다. 그런 다음 다음을 입력합니다. 여기서 IP 주소는 이전에 복사한 EC2 인스턴스의 주소입니다.

   ```
   TEST_IP_ADDRESS=192.168.0.4 rake test
   ```

   Windows Server 인스턴스를 배포하는 경우 **배치 명령 실행**을 선택한 후 다음을 입력합니다. 여기서, IP 주소는 앞에서 복사한 EC2 인스턴스의 주소입니다.

   ```
   set TEST_IP_ADDRESS=192.168.0.4 rake test
   ```
**참고**  
테스트에서는 포트 번호를 기본값인 80으로 간주합니다. 다른 포트를 지정하려면 다음과 같이 테스트 포트 설명문을 추가합니다.  

   ```
   TEST_IP_ADDRESS=192.168.0.4 TEST_PORT=8000 rake test
   ```

1. **빌드 후 작업 추가**를 선택한 다음, **AWS CodePipeline 게시자**를 선택합니다. [**Add**]는 선택하지 마십시오.

1. [**Save**]를 선택하여 Jenkins 프로젝트를 저장합니다.

#### 네 번째 단계 생성
<a name="tutorials-four-stage-pipeline-create-fourth-stage"></a>

**Jenkins 테스트 작업을 포함하는 파이프라인에 단계를 추가하려면**

1. 에 로그인 AWS Management Console 하고 [http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) CodePipeline 콘솔을 엽니다.

1. **이름**에서 앞에서 만든 파이프라인의 이름(MySecondPipeline)을 선택합니다.

1. 파이프라인 세부 정보 페이지에서 [**Edit**]를 선택합니다.

1. [**Edit**] 페이지에서 [**\$1 Stage**]를 선택하여 빌드 단계 바로 다음에 단계를 추가합니다.

1. 새 단계의 이름 필드에 이름(예: **Testing**)을 입력한 다음, **\$1 Add action group(\$1 작업 그룹 추가)**을 선택합니다.

1. [**Action name**]에 *MyJenkinsTest-Action*을 입력합니다. [**Test provider**]에서, Jenkins에 지정한 공급자 이름(예: *MyJenkinsProviderName*)을 선택합니다. [**Project name**]에 Jenkins에서 생성한 프로젝트 이름(예: *MyTestProject*)을 입력합니다. **입력 아티팩트**에서 기본 이름이 *BuildArtifact*인 Jenkins 빌드로부터 아티팩트를 선택한 후 **완료**를 선택합니다.
**참고**  
Jenkins 테스트 작업은 Jenkins 빌드 단계에서 빌드된 애플리케이션에서 실행되므로 이 테스트 작업에 대한 입력 아티팩트에 빌드 아티팩트를 사용하십시오.

   입력 및 출력 아티팩트 및 파이프라인의 구조에 대한 자세한 내용은 [CodePipeline 파이프라인 구조 참조](reference-pipeline-structure.md) 단원을 참조하십시오.

1. [**Edit**] 페이지에서 [**Save pipeline changes**]를 선택합니다. [**Save pipeline changes**] 대화 상자에서 [**Save and continue**]를 선택합니다.

1. 새로운 단계가 파이프라인에 추가되었더라도 변경 사항에 의해 파이프라인이 다시 실행되도록 트리거되지 않았으므로 해당 단계의 상태가 [**No executions yet**]으로 표시됩니다. 개정된 파이프라인을 통해 샘플을 실행하려면 파이프라인 세부 정보 페이지에서 **변경 사항 릴리스**를 선택합니다.

   파이프라인 보기에 파이프라인의 상태 및 작업과 해당 네 단계를 통해 실행되는 개정 상태가 표시됩니다. 파이프라인이 모든 단계를 통해 실행되는 데 걸리는 시간은 아티팩트의 크기, 빌드 및 테스트 작업의 복잡성, 그리고 기타 요인에 따라 달라집니다.

## 4단계: 리소스 정리
<a name="tutorials-four-stage-pipeline-clean-up"></a>

이 자습서를 완료한 후에는 사용한 파이프라인과 리소스를 삭제해야 이 리소스를 계속 사용할 경우 부과되는 요금을 피할 수 있습니다. CodePipeline을 계속 사용하지 않을 경우 파이프라인을 삭제하고 CodeDeploy 애플리케이션과 그에 연결된 Amazon EC2 인스턴스, 끝으로 아티팩트를 저장하는 데 사용된 Amazon S3 버킷을 삭제합니다. 다른 리소스(예: GitHub 리포지토리)를 계속 사용하지 않을 경우 이 리소스를 삭제할지 여부도 고려해야 합니다.

**이 자습서에서 사용한 리소스를 정리하려면**

1. 로컬 Linux, macOS 또는 Unix 머신에서 터미널 세션을 열거나 로컬 Windows 머신에서 명령 프롬프트를 열고, **delete-pipeline** 명령을 실행하여 생성한 파이프라인을 삭제합니다. **MySecondPipeline**의 경우, 다음 명령을 입력합니다.

   ```
   aws codepipeline delete-pipeline --name "MySecondPipeline"
   ```

   이 명령은 아무 것도 반환하지 않습니다.

1. CodeDeploy 리소스를 정리하려면 [정리](https://docs.aws.amazon.com/codedeploy/latest/userguide/getting-started-walkthrough.html#getting-started-walkthrough-clean-up) 단원의 지침을 따릅니다.

1. 인스턴스 리소스를 정리하려면 Jenkins를 설치한 EC2 인스턴스를 삭제합니다. 자세한 내용은 [인스턴스 정리](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-clean-up-your-instance.html)를 참조하십시오.

1. 더 많은 파이프라인을 생성하거나 CodePipeline을 다시 사용하려는 경우, 파이프라인의 아티팩트를 저장하는 데 사용한 Amazon S3 버킷을 삭제합니다. 버킷을 삭제하려면 [버킷 삭제](https://docs.aws.amazon.com/AmazonS3/latest/UG/DeletingaBucket.html)의 지침을 따릅니다.

1. 이 파이프라인에 다른 리소스를 다시 사용하지 않으려는 경우, 해당 특정 리소스에 대한 지침을 따라 이를 삭제하는 것을 고려하십시오. 예를 들어, GitHub 리포지토리를 삭제하려는 경우 GitHub 웹 사이트에서 [리포지토리 삭제](https://help.github.com/articles/deleting-a-repository/)의 지침을 따릅니다.

# 자습서: 파이프라인 상태 변경에 대한 이메일 알림을 수신하도록 CloudWatch Events 규칙 설정
<a name="tutorials-cloudwatch-sns-notifications"></a>

에서 파이프라인을 설정한 후 파이프라인의 실행 상태가 변경될 때마다 또는 파이프라인의 단계 또는 작업이 변경될 때마다 알림을 보내도록 CloudWatch Events 규칙을 설정할 AWS CodePipeline수 있습니다. CloudWatch Events를 사용하여 파이프라인 상태 변경에 대한 알림을 설정하는 방법은 [CodePipeline 이벤트 모니터링](detect-state-changes-cloudwatch-events.md) 단원을 참조하세요.

이 자습서에서는 파이프라인의 상태가 FAILED로 변경되면 이메일을 보내도록 알림을 구성합니다. 이 자습서에서는 CloudWatch Events 규칙을 만들 때 입력 변환기 방법을 사용합니다. 이는 사람이 읽을 수 있는 텍스트로 메시지를 전달하도록 메시지 스키마 세부 정보를 변환합니다.

**참고**  
Amazon SNS 알림 및 CloudWatch Events 규칙과 같은이 자습서의 리소스를 생성할 때 리소스가 파이프라인과 동일한 AWS 리전에 생성되었는지 확인합니다.

**Topics**
+ [1단계: Amazon SNS를 사용하여 이메일 알림 설정](#create-filter-for-target)
+ [2단계: 규칙을 만들고 SNS 주제를 대상으로 추가](#create-notification-rule)
+ [3단계: 리소스 정리](#notifications-clean-up-resources)

## 1단계: Amazon SNS를 사용하여 이메일 알림 설정
<a name="create-filter-for-target"></a>

Amazon SNS는 주제 사용을 조정하여 구독 엔드포인트 또는 클라이언트에 메시지를 전달합니다. Amazon SNS를 사용하여 알림 주제를 만든 후 이메일 주소를 사용하여 해당 주제를 구독합니다. Amazon SNS 주제가 CloudWatch Events 규칙에 대상으로 추가됩니다. 자세한 내용은 [Amazon Simple Notification Service Developer Guide](https://docs.aws.amazon.com/sns/latest/dg/)를 참조하십시오.

Amazon SNS 주제를 생성하거나 식별합니다. CodePipeline은 CloudWatch Events를 사용하여 Amazon SNS를 통해 이 주제에 대한 알림을 보냅니다. 주제를 생성하려면 다음과 같이 합니다.

1. [https://console.aws.amazon.com/sns](https://console.aws.amazon.com/sns) Amazon SNS 콘솔을 엽니다.

1. **주제 생성**을 선택합니다.

1. **새로운 주제 생성** 대화 상자의 **주제 이름**에 주제 이름(예: **PipelineNotificationTopic**)을 입력합니다.  
![\[Amazon SNS를 사용하여 알림 주제를 생성합니다.\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/tutorial-SNS-topic.png)

1. **주제 생성**을 선택합니다.

   자세한 내용은 *Amazon SNS 개발자 안내서*의 [주제 생성](https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html)을 참조하세요.

한 명 이상의 수신자가 주제를 구독하여 이메일 알림을 수신하게 합니다. 수신자가 주제를 구독하게 하려면 다음과 같이 합니다.

1. Amazon SNS 콘솔의 **주제** 목록에서 새 주제 옆의 확인란을 선택합니다. [**Actions, Subscribe to topic**]을 선택합니다.

1. [**Create subscription**] 대화 상자에서 ARN이 [**Topic ARN**]에 표시되는지 확인합니다.

1. **프로토콜**에서 **이메일**을 선택합니다.

1. **엔드포인트**에 수신자의 전체 이메일 주소를 입력합니다.

1. **구독 생성**을 선택합니다.

1. Amazon SNS가 수신자에게 구독 확인 이메일을 보냅니다. 이메일 알림을 수신하려면 수신자는 이 이메일에서 [**Confirm subscription**] 링크를 선택해야 합니다. 수신자가 링크를 클릭한 후 구독에 성공하면 Amazon SNS가 해당 수신자의 웹 브라우저에 확인 메시지를 표시합니다.

   자세한 내용은 *Amazon SNS 개발자 가이드*의 [주제 구독](https://docs.aws.amazon.com/sns/latest/dg/SubscribeTopic.html)을 참조하세요.

## 2단계: 규칙을 만들고 SNS 주제를 대상으로 추가
<a name="create-notification-rule"></a>

CodePipeline이 이벤트 소스인 CloudWatch Events 알림 규칙을 만듭니다.

1. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)에서 CloudWatch 콘솔을 엽니다.

1. 탐색 창에서 **이벤트**를 선택합니다.

1. **규칙 생성**을 선택합니다. **이벤트 소스** 아래에서 **AWS CodePipeline**을 선택합니다. [**Event Type**]에서 [**Pipeline Execution State Change**]를 선택합니다.

1. **특정 상태**를 선택한 후 **FAILED**를 선택합니다.

1. [**Edit**]를 선택하여 [**Event Pattern Preview**] 창의 JSON 편집기를 엽니다. 파이프라인 이름이 "myPipeline"인 다음 예와 같이 파이프라인 이름을 지정하여 **pipeline** 파라미터를 추가합니다.

   여기에서 이벤트 패턴을 복사하여 콘솔에 붙여 넣을 수 있습니다.

   ```
   {
     "source": [
       "aws.codepipeline"
     ],
     "detail-type": [
       "CodePipeline Pipeline Execution State Change"
     ],
     "detail": {
       "state": [
         "FAILED"
       ],
       "pipeline": [
         "myPipeline"
       ]
     }
   }
   ```

1. **대상(Targets)**에서 **대상 추가(Add target)**를 선택합니다.

1. 대상 목록에서 **SNS 주제**를 선택합니다. [**Topic**]에 생성한 주제를 입력합니다.

1. **입력 구성**을 확장한 후 **입력 변환기**를 선택합니다.

1. [**Input Path**] 상자에 다음 키-값 페어를 입력합니다.

   ```
   { "pipeline" : "$.detail.pipeline" }
   ```

   [**Input Template**] 상자에 다음을 입력합니다.

   ```
   "The Pipeline <pipeline> has failed."
   ```

1. **세부 정보 구성**을 선택합니다.

1. [**Configure rule details**] 페이지에 이름과 설명(선택 사항)을 입력합니다. [**State**]에서 [**Enabled**] 상자를 선택된 상태로 둡니다.

1. **규칙 생성**을 선택합니다.

1. CodePipeline이 현재 빌드 알림을 보내고 있는지 확인합니다. 예를 들어 빌드 알림 이메일이 현재 받은 편지함에 있는지 확인합니다.

1. 규칙의 동작을 변경하려면 CloudWatch 콘솔에서 규칙을 선택한 후 **작업**, **편집**을 선택합니다. 규칙을 편집하고 [**Configure details**]를 선택한 후 [**Update rule**]을 선택합니다.

   규칙을 사용하여 빌드 알림을 보내는 것을 중지하려면 CloudWatch 콘솔에서 해당 규칙을 선택한 후 **작업**, **비활성화**를 선택합니다.

   규칙을 삭제하려면 CloudWatch 콘솔에서 해당 규칙을 선택한 후 **작업**, **삭제**를 선택합니다.

## 3단계: 리소스 정리
<a name="notifications-clean-up-resources"></a>

이 자습서를 완료한 후에는 사용한 파이프라인과 리소스를 삭제해야 이 리소스를 계속 사용할 경우 부과되는 요금을 피할 수 있습니다.

SNS 알림을 정리하고 Amazon CloudWatch Events 규칙을 삭제하는 방법에 대한 자세한 내용은 [정리(Amazon SNS 주제에서 구독 취소)](https://docs.aws.amazon.com/sns/latest/dg/CleanUp.html) 및 [Amazon CloudWatch Events API 참조](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/)의 `DeleteRule`을 참조하세요.

# 자습서:를 사용하여 Android 앱을 빌드하고 테스트하는 파이프라인 생성 AWS Device Farm
<a name="tutorials-codebuild-devicefarm"></a>

 AWS CodePipeline 를 사용하여 커밋이 푸시될 때마다 앱이 빌드되고 테스트되는 지속적인 통합 흐름을 구성할 수 있습니다. 이 자습서는 GitHub 리포지토리에서 소스 코드로 Android 앱을 빌드하고 테스트하는 파이프라인을 생성하고 구성하는 방법을 보여줍니다. 파이프라인은 새로운 GitHub 커밋의 도착을 감지한 다음 [CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/welcome.html)를 사용하여 앱을 빌드하고 [Device Farm](https://docs.aws.amazon.com/devicefarm/latest/developerguide/welcome.html)을 사용하여 앱을 테스트합니다.

**중요**  
콘솔에서 파이프라인을 생성하는 과정에서 CodePipeline은 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

**중요**  
이 절차에서 파이프라인에 추가하는 많은 작업에는 파이프라인을 생성하기 전에 생성해야 하는 AWS 리소스가 포함됩니다. 소스 작업에 대한 AWS 리소스는 항상 파이프라인을 생성하는 리전과 동일한 AWS 리전에서 생성해야 합니다. 예를 들어, 미국 동부(오하이오) 리전에서 파이프라인을 생성하는 경우, CodeCommit 리포지토리도 미국 동부(오하이오) 리전에 있어야 합니다.  
파이프라인을 생성할 때 교차 리전 작업을 추가할 수 있습니다. 교차 리전 작업에 대한 AWS 리소스는 작업을 실행하려는 리전과 동일한 AWS 리전에 있어야 합니다. 자세한 내용은 [CodePipeline에 교차 리전 작업 추가](actions-create-cross-region.md) 단원을 참조하십시오.

기존 Android 앱 및 테스트 정의를 사용하여 시도하거나 [Device Farm에서 제공하는 샘플 앱 및 테스트 정의](https://github.com/aws-samples/aws-device-farm-sample-app-for-android)를 사용할 수 있습니다.

**시작하기 전에**

1.  AWS Device Farm 콘솔에 로그인하고 **새 프로젝트 생성을** 선택합니다.

1. 프로젝트를 선택합니다. 브라우저에서 새 프로젝트의 URL을 복사합니다. URL에 프로젝트 ID가 포함되어 있습니다.

1. 이 프로젝트 ID를 복사하여 보관합니다. CodePipeline에서 파이프라인을 생성할 때 사용합니다.

   다음은 프로젝트 URL의 예입니다. 프로젝트 ID를 추출하려면 `projects/` 뒤의 값을 복사합니다. 이 예시에서 제품 ID는 `eec4905f-98f8-40aa-9afc-4c1cfexample`입니다.

   ```
   https://<region-URL>/devicefarm/home?region=us-west-2#/projects/eec4905f-98f8-40aa-9afc-4c1cfexample/runs
   ```

## Device Farm 테스트를 사용하도록 CodePipeline 구성
<a name="codepipeline-configure-tests"></a>

1. 

   앱 코드의 루트에서 [https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html)이라는 파일을 추가하고 커밋한 다음 리포지토리로 푸시합니다. CodeBuild는 이 파일을 사용하여 앱을 빌드하는 데 필요한 명령을 수행하고 아티팩트에 액세스합니다.

   ```
   version: 0.2
   
   phases:
     build:
       commands:
         - chmod +x ./gradlew
         - ./gradlew assembleDebug
   artifacts:
     files:
        - './android/app/build/outputs/**/*.apk'
     discard-paths: yes
   ```

1. (선택 사항) [Calabash 또는 Appium을 사용하여 앱을 테스트한 경우](https://docs.aws.amazon.com/devicefarm/latest/developerguide/test-types-intro.html) 테스트 정의 파일을 리포지토리에 추가합니다. 이후 단계에서 테스트 제품군을 수행하기 위한 정의를 사용하도록 Device Farm을 구성할 수 있습니다.

   Device Farm 내장형 테스트를 사용하는 경우 이 단계를 건너뛸 수 있습니다.

1. 파이프라인을 생성하고 소스 단계를 추가하려면 다음을 수행합니다.

   1. 에 로그인 AWS Management Console 하고 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) CodePipeline 콘솔을 엽니다.

   1. [**Welcome**] 페이지, [**Getting started**] 페이지 또는 [**Pipelines**] 페이지에서 **Create pipeline(파이프라인 생성)**을 선택합니다.

   1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

   1. **2단계: 파이프라인 설정 선택** 페이지의 **파이프라인 이름**에 파이프라인 이름을 입력합니다.

   1. CodePipeline은 특성과 가격이 다른 V1 및 V2 유형 파이프라인을 제공합니다. V2 유형은 콘솔에서 선택할 수 있는 유일한 유형입니다. 자세한 내용은 [파이프라인 유형](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)을 참조하세요. CodePipeline에 대한 요금 정보는 [요금](https://aws.amazon.com/codepipeline/pricing/)을 참조하세요.

   1. **서비스 역할**에서 **새 서비스 역할**을 선택된 상태로 두고, **역할 이름**도 변경하지 않고 그대로 둡니다. 이미 있는 경우 기존 서비스 역할을 사용하도록 선택할 수도 있습니다.
**참고**  
2018년 7월 이전에 생성된 CodePipeline 서비스 역할을 사용할 경우 Device Farm에 대한 권한을 추가해야 합니다. 이렇게 하려면 IAM 콘솔을 열고 역할을 찾은 다음 역할의 정책에 다음 권한을 추가합니다. 자세한 내용은 [CodePipeline 서비스 역할에 권한 추가](how-to-custom-role.md#how-to-update-role-new-services) 단원을 참조하십시오.  

      ```
      {
           "Effect": "Allow",
           "Action": [
              "devicefarm:ListProjects",
              "devicefarm:ListDevicePools",
              "devicefarm:GetRun",
              "devicefarm:GetUpload",
              "devicefarm:CreateUpload",
              "devicefarm:ScheduleRun"
           ],
           "Resource": "*"
      }
      ```

   1. [**Advanced settings**]의 설정은 기본값 그대로 두고, [**Next**]를 선택합니다.

   1. **3단계: 소스 스테이지 추가** 페이지의 **소스 공급자**에서 **GitHub(앱 사용)**를 선택합니다.

   1. **연결**에서 기존 연결을 선택하거나 새로 생성합니다. GitHub 소스 작업에 대한 연결을 만들거나 관리하려면 [GitHub 연결](connections-github.md)을 참조하세요.

   1. **리포지토리**에서 소스 리포지토리를 선택합니다.

   1. **브랜치**에서 사용할 브랜치를 선택합니다.

   1. 소스 작업의 나머지 기본값은 그대로 둡니다. **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가**에서 빌드 스테이지를 추가합니다.

   1. **빌드 공급자**에서 **기타 빌드 공급자**를 선택한 후 **AWS CodeBuild**를 선택합니다. **리전**이 파이프라인 리전으로 기본 설정되도록 합니다.

   1. **프로젝트 생성**을 선택합니다.

   1. **프로젝트 이름**에 이 빌드 프로젝트의 이름을 입력합니다.

   1. **환경 이미지**에서 **이미지 관리**를 선택합니다. [**Operating system**]에서 [**Ubuntu**]를 선택합니다.

   1. **실행 시간**에서 **표준**을 선택합니다. **이미지**에서 **aws/codebuild/standard:5.0**을 선택합니다.

      CodeBuild는 앱을 빌드하기 위해 Android Studio가 설치된 이 OS 이미지를 사용합니다.

   1. **서비스 역할**에 기존 CodeBuild 서비스 역할을 선택하거나 새 역할을 생성합니다.

   1. **Build specifications(빌드 사양)**에서 **Use a buildspec file(빌드 사양 파일 사용)**을 선택합니다.

   1. **Continue to CodePipeline(CodePipeline으로 계속)**을 선택합니다. 이렇게 하면 CodePipeline 콘솔로 반환되고 구성을 위해 리포지토리에서 `buildspec.yml`을 사용하는 CodeBuild 프로젝트를 생성합니다. 빌드 프로젝트가 서비스 역할을 사용하여 AWS 서비스 권한을 관리합니다. 이 단계는 몇 분이 걸릴 수 있습니다.

   1. **다음**을 선택합니다.

1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **6단계: 배포 단계 추가** 페이지에서 **배포 단계 건너뛰기를** 선택한 다음 다시 **건너뛰기를** 선택하여 경고 메시지를 수락합니다. **다음**을 선택합니다.

1. **7단계: 검토**에서 **파이프라인 생성을** 선택합니다. 소스 및 빌드 단계를 보여주는 다이어그램을 확인해야 합니다.

1. 파이프라인에 Device Farm 테스트 작업을 추가하세요.

   1. 오른쪽 위에서 **편집**을 선택합니다.

   1. 다이어그램의 하단에서 **\$1 단계 추가**를 선택합니다. **Stage name(스테이지 이름)**에서 이름(예: **Test**)을 입력합니다.

   1. **\$1 Add action group(작업 그룹 추가)**을 선택합니다.

   1. **작업 이름**에 이름을 입력하세요.

   1. **작업 공급자**에서 **AWS Device Farm**을 선택합니다. **리전**이 파이프라인 리전으로 기본 설정되도록 합니다.

   1. **입력 아티팩트**에서 `BuildArtifact`과 같이 파이프라인의 테스트 스테이지 전에 오는 단계의 출력 아티팩트와 일치하는 입력 아티팩트를 선택합니다.

       AWS CodePipeline 콘솔에서 파이프라인 다이어그램의 정보 아이콘 위로 마우스를 가져가면 각 단계의 출력 아티팩트 이름을 찾을 수 있습니다. **소스** 스테이지에서 파이프라인이 바로 앱을 테스트하면 **SourceArtifact**를 선택합니다. 파이프라인이 **빌드** 단계를 포함하면 **BuildArtifact**를 선택합니다.

   1. **ProjectId**에 Device Farm 프로젝트 ID를 입력합니다. 이 자습서의 시작 부분에 있는 단계를 따라 프로젝트 ID를 검색합니다.

   1. **DevicePoolArn**에서 디바이스 풀의 ARN을 입력합니다. 상위 디바이스에 대한 ARNs을 포함하여 프로젝트에 사용 가능한 디바이스 풀 ARN을 가져오려면 AWS CLI를 사용하여 다음 명령을 입력합니다.

      ```
      aws devicefarm list-device-pools --arn arn:aws:devicefarm:us-west-2:account_ID:project:project_ID
      ```

   1. **AppType**에서 **Android**를 입력합니다.

      **AppType**의 유효한 값 목록은 다음과 같습니다.
      + **iOS**
      + **Android**
      + **웹**

   1. **앱**에서 컴파일된 앱 패키지의 경로를 입력합니다. 경로는 테스트 단계용 입력 아티팩트의 루트와 상대적입니다. 일반적으로 이 경로는 `app-release.apk`와 유사합니다.

   1. **TestType**에 테스트 유형을 입력한 다음, **테스트**에 테스트 정의 파일의 경로를 입력합니다. 경로는 테스트용 입력 아티팩트의 루트와 상대적입니다.

      **TestType**의 유효한 값 목록은 다음과 같습니다.
      + **APPIUM\$1JAVA\$1JUNIT**
      + **APPIUM\$1JAVA\$1TESTNG**
      + **APPIUM\$1NODE**
      + **APPIUM\$1RUBY**
      + **APPIUM\$1PYTHON**
      + **APPIUM\$1WEB\$1JAVA\$1JUNIT**
      + **APPIUM\$1WEB\$1JAVA\$1TESTNG**
      + **APPIUM\$1WEB\$1NODE**
      + **APPIUM\$1WEB\$1RUBY**
      + **APPIUM\$1WEB\$1PYTHON**
      + **BUILTIN\$1FUZZ**
      + **INSTRUMENTATION**
      + **XCTEST**
      + **XCTEST\$1UI**
**참고**  
사용자 지정 환경 노드는 지원되지 않습니다.

   1. 나머지 필드에서 테스트 및 애플리케이션 유형에 적절한 구성을 제공하세요.

   1. (선택 사항) **고급**에서 테스트 실행 시 구성 정보를 제공합니다.

   1. **저장**을 선택합니다.

   1. 편집 중인 스테이지에서 **완료**를 선택합니다. AWS CodePipeline 창에서 **저장**을 선택한 다음 경고 메시지에서 **저장**을 선택합니다.

   1. 변경 사항을 제출하고 파이프라인 빌드를 시작하려면 **변경 사항 배포**를 선택한 다음 **릴리스**를 선택하세요.

# 자습서:를 사용하여 iOS 앱을 테스트하는 파이프라인 생성 AWS Device Farm
<a name="tutorials-codebuild-devicefarm-S3"></a>

 AWS CodePipeline 를 사용하여 소스 버킷이 변경될 때마다 앱을 테스트하는 지속적인 통합 흐름을 쉽게 구성할 수 있습니다. 이 자습서는 S3 버킷에서 빌드된 iOS 앱을 테스트하는 파이프라인을 생성하고 구성하는 방법을 보여줍니다. 파이프라인은 Amazon CloudWatch Events을 통해 저장된 변경 사항의 도착을 감지한 다음 [Device Farm](https://docs.aws.amazon.com/devicefarm/latest/developerguide/welcome.html)을 사용하여 빌드된 애플리케이션을 테스트합니다.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

**중요**  
이 절차에서 파이프라인에 추가하는 많은 작업에는 파이프라인을 생성하기 전에 생성해야 하는 AWS 리소스가 포함됩니다. 소스 작업에 대한 AWS 리소스는 항상 파이프라인을 생성하는 리전과 동일한 AWS 리전에서 생성해야 합니다. 예를 들어, 미국 동부(오하이오) 리전에서 파이프라인을 생성하는 경우, CodeCommit 리포지토리도 미국 동부(오하이오) 리전에 있어야 합니다.  
파이프라인을 생성할 때 교차 리전 작업을 추가할 수 있습니다. 교차 리전 작업에 대한 AWS 리소스는 작업을 실행하려는 리전과 동일한 AWS 리전에 있어야 합니다. 자세한 내용은 [CodePipeline에 교차 리전 작업 추가](actions-create-cross-region.md) 단원을 참조하십시오.

기존 iOS 앱을 사용하여 시도하거나 [샘플 iOS 앱](samples/s3-ios-test-1.zip)을 사용할 수 있습니다.

**시작하기 전에**

1.  AWS Device Farm 콘솔에 로그인하고 **새 프로젝트 생성을** 선택합니다.

1. 프로젝트를 선택합니다. 브라우저에서 새 프로젝트의 URL을 복사합니다. URL에 프로젝트 ID가 포함되어 있습니다.

1. 이 프로젝트 ID를 복사하여 보관합니다. CodePipeline에서 파이프라인을 생성할 때 사용합니다.

   다음은 프로젝트 URL의 예입니다. 프로젝트 ID를 추출하려면 `projects/` 뒤의 값을 복사합니다. 이 예시에서 제품 ID는 `eec4905f-98f8-40aa-9afc-4c1cfexample`입니다.

   ```
   https://<region-URL>/devicefarm/home?region=us-west-2#/projects/eec4905f-98f8-40aa-9afc-4c1cfexample/runs
   ```

## Device Farm 테스트를 사용하도록 CodePipeline 구성(Amazon S3 예)
<a name="codepipeline-configure-tests-S3"></a>

1. 버전 관리가 활성화된 S3 버킷을 생성하거나 사용합니다. [1단계: 애플리케이션에 대한 S3 소스 버킷 생성](tutorials-simple-s3.md#s3-create-s3-bucket)의 지침을 따라 S3 버킷을 생성합니다.

1. 버킷의 Amazon S3 콘솔에서 업로드를 선택하고 지침을 따라 .zip 파일을 **업로드**합니다.

   샘플 애플리케이션은 .zip 파일로 압축해야 합니다.

1. 파이프라인을 생성하고 소스 단계를 추가하려면 다음을 수행합니다.

   1. 에 로그인 AWS Management Console 하고 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) CodePipeline 콘솔을 엽니다.

   1. [**Welcome**] 페이지, [**Getting started**] 페이지 또는 [**Pipelines**] 페이지에서 **Create pipeline(파이프라인 생성)**을 선택합니다.

   1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

   1. **2단계: 파이프라인 설정 선택** 페이지의 **파이프라인 이름**에 파이프라인 이름을 입력합니다.

   1. CodePipeline은 특성과 가격이 다른 V1 및 V2 유형 파이프라인을 제공합니다. V2 유형은 콘솔에서 선택할 수 있는 유일한 유형입니다. 자세한 내용은 [파이프라인 유형](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)을 참조하세요. CodePipeline에 대한 요금 정보는 [요금](https://aws.amazon.com/codepipeline/pricing/)을 참조하세요.

   1. **서비스 역할**에서 **새 서비스 역할**을 선택된 상태로 두고, **역할 이름**도 변경하지 않고 그대로 둡니다. 이미 있는 경우 기존 서비스 역할을 사용하도록 선택할 수도 있습니다.
**참고**  
2018년 7월 이전에 생성된 CodePipeline 서비스 역할을 사용할 경우 Device Farm에 대한 권한을 추가해야 합니다. 이렇게 하려면 IAM 콘솔을 열고 역할을 찾은 다음 역할의 정책에 다음 권한을 추가합니다. 자세한 내용은 [CodePipeline 서비스 역할에 권한 추가](how-to-custom-role.md#how-to-update-role-new-services) 단원을 참조하십시오.  

      ```
      {
           "Effect": "Allow",
           "Action": [
              "devicefarm:ListProjects",
              "devicefarm:ListDevicePools",
              "devicefarm:GetRun",
              "devicefarm:GetUpload",
              "devicefarm:CreateUpload",
              "devicefarm:ScheduleRun"
           ],
           "Resource": "*"
      }
      ```

   1. [**Advanced settings**]의 설정은 기본값 그대로 두고, [**Next**]를 선택합니다.

   1. **3단계: 소스 스테이지 추가** 페이지의 **소스 공급자**에서 **Amazon S3**를 선택합니다.

   1. **Amazon S3 위치**에 버킷(예: `my-storage-bucket`) 및 객체 키(예: .zip 파일의 `s3-ios-test-1.zip`)를 입력합니다.

   1. **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가**에서 파이프라인에 대한 자리 표시자 빌드 스테이지를 생성합니다. 이렇게 하면 마법사에서 파이프라인을 생성할 수 있습니다. 마법사를 사용하여 두 단계 파이프라인을 만든 후에는 자리 표시자 빌드 단계가 더 이상 필요 없습니다. 파이프라인이 완료된 후에는 이 두 번째 단계가 삭제되고 새로운 테스트 단계가 5단계에 추가됩니다.

   

   1. **빌드 공급자**에서 **Jenkins 추가**를 선택합니다. 이 빌드 선택은 자리 표시자입니다. 사용되지 않습니다.

   1. **공급자 이름**에 이름을 입력합니다. 이름은 자리 표시자입니다. 사용되지 않습니다.

   1. **서버 URL**에 텍스트를 입력합니다. 텍스트는 자리 표시자입니다. 사용되지 않습니다.

   1. **프로젝트 이름**에 이름을 입력합니다. 이름은 자리 표시자입니다. 사용되지 않습니다.

   1. **다음**을 선택합니다.

   1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

      **다음**을 선택합니다.

   1. **6단계: 배포 단계 추가** 페이지에서 **배포 단계 건너뛰기를** 선택한 다음 다시 **건너뛰기를** 선택하여 경고 메시지를 수락합니다.

   1. **7단계: 검토**에서 **파이프라인 생성을** 선택합니다. 소스 및 빌드 단계를 보여주는 다이어그램을 확인해야 합니다.  
![\[\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/codepipeline-view-pipeline-S3.png)

1. 다음과 같이 파이프라인에 Device Farm 테스트 작업을 추가합니다.

   1. 오른쪽 위에서 **편집**을 선택합니다.

   1. **Edit stage(단계 편집)**을 선택합니다. **삭제**를 선택합니다. 그러면 자리 표시자 단계가 삭제됩니다(이제 더 이상 파이프라인 생성에 필요 없으므로).

   1. 다이어그램의 하단에서 **\$1 단계 추가**를 선택합니다.

   1. 스테이지 이름에서 스테이지 이름(예: 테스트)을 입력한 다음 **Add stage(스테이지 추가)**를 선택합니다.

   1. **\$1 Add action group(작업 그룹 추가)**을 선택합니다.

   1. **작업 이름**에서 이름(예: DeviceFarmTest)을 입력합니다.

   1. **작업 공급자**에서 **AWS Device Farm**을 선택합니다. **리전**이 파이프라인 리전으로 기본 설정되도록 합니다.

   1. **입력 아티팩트**에서 `SourceArtifact`과 같이 파이프라인의 테스트 스테이지 전에 오는 단계의 출력 아티팩트와 일치하는 입력 아티팩트를 선택합니다.

       AWS CodePipeline 콘솔에서 파이프라인 다이어그램의 정보 아이콘 위로 마우스를 가져가면 각 단계의 출력 아티팩트 이름을 찾을 수 있습니다. **소스** 스테이지에서 파이프라인이 바로 앱을 테스트하면 **SourceArtifact**를 선택합니다. 파이프라인이 **빌드** 단계를 포함하면 **BuildArtifact**를 선택합니다.

   1. **ProjectId**에서 Device Farm 프로젝트 ID를 선택합니다. 이 자습서의 시작 부분에 있는 단계를 따라 프로젝트 ID를 검색합니다.

   1. **DevicePoolArn**에서 디바이스 풀의 ARN을 입력합니다. 상위 디바이스에 대한 ARNs을 포함하여 프로젝트에 사용 가능한 디바이스 풀 ARN을 가져오려면 AWS CLI를 사용하여 다음 명령을 입력합니다.

      ```
      aws devicefarm list-device-pools --arn arn:aws:devicefarm:us-west-2:account_ID:project:project_ID
      ```

   1. **AppType**에서 **iOS**를 입력합니다.

      **AppType**의 유효한 값 목록은 다음과 같습니다.
      + **iOS**
      + **Android**
      + **웹**

   1. **앱**에서 컴파일된 앱 패키지의 경로를 입력합니다. 경로는 테스트 단계용 입력 아티팩트의 루트와 상대적입니다. 일반적으로 이 경로는 `ios-test.ipa`와 유사합니다.

   1. **TestType**에 테스트 유형을 입력한 다음, **테스트**에 테스트 정의 파일의 경로를 입력합니다. 경로는 테스트용 입력 아티팩트의 루트와 상대적입니다.

      내장형 Device Farm 테스트 중 하나를 사용하는 경우 Device Farm 프로젝트에 구성된 테스트 유형(예: BUILTIN\$1FUZZ)을 선택합니다. **FuzzEventCount**에서 밀리초 단위로 시간을 입력합니다(예: 6000). **FuzzEventThrottle**에서 밀리초 단위로 시간을 입력합니다(예: 50).

      내장형 Device Farm 테스트 중 하나를 사용하지 않는 경우, 테스트 유형을 선택한 다음 **테스트**에서 테스트 정의 파일의 경로를 입력합니다. 경로는 테스트용 입력 아티팩트의 루트와 상대적입니다.

      **TestType**의 유효한 값 목록은 다음과 같습니다.
      + **APPIUM\$1JAVA\$1JUNIT**
      + **APPIUM\$1JAVA\$1TESTNG**
      + **APPIUM\$1NODE**
      + **APPIUM\$1RUBY**
      + **APPIUM\$1PYTHON**
      + **APPIUM\$1WEB\$1JAVA\$1JUNIT**
      + **APPIUM\$1WEB\$1JAVA\$1TESTNG**
      + **APPIUM\$1WEB\$1NODE**
      + **APPIUM\$1WEB\$1RUBY**
      + **APPIUM\$1WEB\$1PYTHON**
      + **BUILTIN\$1FUZZ**
      + **INSTRUMENTATION**
      + **XCTEST**
      + **XCTEST\$1UI**
**참고**  
사용자 지정 환경 노드는 지원되지 않습니다.

   1. 나머지 필드에서 테스트 및 애플리케이션 유형에 적절한 구성을 제공하세요.

   1. (선택 사항) **고급**에서 테스트 실행 시 구성 정보를 제공합니다.

   1. **저장**을 선택합니다.

   1. 편집 중인 스테이지에서 **완료**를 선택합니다. AWS CodePipeline 창에서 **저장**을 선택한 다음 경고 메시지에서 **저장**을 선택합니다.

   1. 변경 사항을 제출하고 파이프라인 실행을 시작하려면 **변경 사항 배포**를 선택한 다음 **릴리스**를 선택합니다.

# 자습서: Service Catalog에 배포하는 파이프라인 생성
<a name="tutorials-S3-servicecatalog"></a>

Service Catalog를 사용하면 AWS CloudFormation 템플릿을 기반으로 제품을 생성하고 프로비저닝할 수 있습니다.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

이 자습서에서는 Service Catalog에 제품 템플릿을 배포하고 소스 리포지토리(이미 GitHub, CodeCommit 또는 Amazon S3에 생성됨)에서 변경한 사항을 제공하기 위해 파이프라인을 생성하고 구성하는 방법을 보여 줍니다.

**참고**  
Amazon S3가 파이프라인의 소스 공급자인 경우, 단일 .zip 파일로 패키지된 모든 소스 파일을 버킷에 업로드해야 합니다. 그렇지 않으면 소스 작업이 실패합니다.

먼저 Service Catalog에서 제품을 생성한 다음 AWS CodePipeline에서 파이프 라인을 생성합니다. 이 자습서에서는 배포 구성을 설정하기 위한 두 가지 옵션을 제공합니다.
+ Service Catalog에서 제품을 생성하고 소스 리포지토리에 템플릿 파일을 업로드합니다. 별도의 구성 파일 없이 CodePipeline 콘솔에서 제품 버전 및 배포 구성을 제공합니다. [옵션 1: 구성 파일 없이 Service Catalog에 배포](#tutorials-S3-servicecatalog-ex1-configure)을(를) 참조하세요.
**참고**  
템플릿 파일은 YAML 또는 JSON 형식으로 생성할 수 있습니다.
+ Service Catalog에서 제품을 생성하고 소스 리포지토리에 템플릿 파일을 업로드합니다. 별도의 구성 파일에서 제품 버전 및 배포 구성을 제공합니다. [옵션 2: 구성 파일을 사용하여 Service Catalog에 배포](#tutorials-S3-servicecatalog-ex2-configure)을(를) 참조하세요.

## 옵션 1: 구성 파일 없이 Service Catalog에 배포
<a name="tutorials-S3-servicecatalog-ex1-configure"></a>

이 예제에서는 S3 버킷에 대한 샘플 AWS CloudFormation 템플릿 파일을 업로드한 다음 Service Catalog에서 제품을 생성합니다. 그런 다음 파이프라인을 생성하고 CodePipeline 콘솔에서 배포 구성을 지정합니다.

### 1단계: 샘플 템플릿 파일을 소스 리포지토리에 업로드
<a name="tutorials-S3-servicecatalog-configure"></a>

1. 텍스트 편집기를 엽니다. 다음을 파일에 붙여 넣고 샘플 템플릿을 생성합니다. 파일을 `S3_template.json`(으)로 저장합니다.

   ```
   {
     "AWSTemplateFormatVersion": "2010-09-09",
     "Description": "CloudFormation Sample Template S3_Bucket: Sample template showing how to create a privately accessible S3 bucket. **WARNING** This template creates an S3 bucket. You will be billed for the resources used if you create a stack from this template.",
     "Resources": {
       "S3Bucket": {
         "Type": "AWS::S3::Bucket",
         "Properties": {}
       }
     },
     "Outputs": {
       "BucketName": {
         "Value": {
           "Ref": "S3Bucket"
         },
         "Description": "Name of Amazon S3 bucket to hold website content"
       }
     }
   }
   ```

   이 템플릿을 사용하면가 Service Catalog에서 사용할 수 있는 S3 버킷을 AWS CloudFormation 생성할 수 있습니다.

1.  AWS CodeCommit 리포지토리에 `S3_template.json` 파일을 업로드합니다.

### 2단계: Service Catalog에서 제품 생성
<a name="tutorials-S3-servicecatalog-product"></a>

1. IT 관리자로 Service Catalog 콘솔에 로그인하고 **제품** 페이지로 이동한 다음 **제품 신규 업로드**를 선택합니다.

1. **제품 신규 업로드** 페이지에서 다음 작업을 완료합니다.

   1. **제품 이름**에 새 제품에 사용할 이름을 입력합니다.

   1. **설명**에 제품 카탈로그 설명을 입력합니다. 이 설명은 사용자가 올바른 제품을 선택할 수 있도록 제품 목록에 표시됩니다.

   1. **공급자** - IT 부서 또는 관리자의 이름을 입력합니다.

   1. **다음**을 선택합니다.

1. (선택 사항) **지원 세부 정보 입력** 페이지에서 제품 지원에 대한 연락처 정보를 입력하고 **다음**을 선택합니다.

1. **버전 세부 정보**에서 다음을 완료합니다.

   1. **템플릿 파일 업로드**를 선택합니다. `S3_template.json` 파일을 찾고 업로드합니다.

   1. **버전 제목** - 제품 버전의 이름을 입력합니다(예: **devops S3 v2**).

   1. **설명**에서 이 버전을 다른 버전과 구별하는 세부 정보를 입력합니다.

   1. **다음**을 선택합니다.

1. **검토** 페이지에서 정보가 올바른지 확인한 다음 **생성**을 선택합니다.

1. **제품** 페이지의 브라우저에서 새 제품의 URL을 복사합니다. 이는 제품 ID를 포함합니다. 이 제품 ID를 복사하여 보관합니다. CodePipeline에서 파이프라인을 생성할 때 사용합니다.

   다음은 `my-product` 제품의 URL입니다. 제품 ID를 추출하려면 등호 기호(`=`) 및 앰퍼샌드(`&`) 사이의 값을 복사합니다. 이 예시에서의 제품 ID는 `prod-example123456`입니다.

   ```
   https://<region-URL>/servicecatalog/home?region=<region>#/admin-products?productCreated=prod-example123456&createdProductTitle=my-product
   ```
**참고**  
페이지에서 벗어나기 전에 제품의 URL을 복사합니다. 이 페이지를 벗어난 후 CLI를 사용하여 제품 ID를 얻어야 합니다.

   몇 초 후 **제품** 페이지에 제품이 표시됩니다. 목록의 제품을 보기 위해 브라우저를 새로 고쳐야 할 수도 있습니다.

### 3단계: 파이프라인 생성
<a name="tutorials-S3-servicecatalog-pipeline"></a>

1. 파이프라인에 이름을 지정하고 파이프라인에 대한 파라미터를 선택하려면 다음을 수행합니다.

   1. 에 로그인 AWS Management Console 하고 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) CodePipeline 콘솔을 엽니다.

   1. [**Welcome**] 페이지, [**Getting started**] 페이지 또는 [**Pipelines**] 페이지에서 **Create pipeline(파이프라인 생성)**을 선택합니다.

   1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

   1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 파이프라인 이름을 입력합니다.

   1. CodePipeline은 특성과 가격이 다른 V1 및 V2 유형 파이프라인을 제공합니다. V2 유형은 콘솔에서 선택할 수 있는 유일한 유형입니다. 자세한 내용은 [파이프라인 유형](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)을 참조하세요. CodePipeline에 대한 요금 정보는 [요금](https://aws.amazon.com/codepipeline/pricing/)을 참조하세요.

   1. **서비스 역할**에서 **새 서비스 역할**을 선택하여CodePipeline이 IAM에 서비스 역할을 생성하도록 허용합니다.

   1. [**Advanced settings**]의 설정은 기본값 그대로 두고, [**Next**]를 선택합니다.

1. **3단계: 소스 스테이지 추가** 페이지에서 소스 스테이지를 추가하려면 다음을 수행합니다.

   1. **소스 공급자**에서 **AWS CodeCommit**을 선택합니다.

   1. **리포지토리 이름** 및 **브랜치 이름**에서 소스 작업에 사용할 리포지토리와 브랜치를 입력합니다.

   1. **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가**에서 **빌드 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **6단계: 배포 스테이지 추가**에서 다음을 완료합니다.

   1. **Deploy provider(배포 공급자)**에서 **AWS Service Catalog**를 선택합니다.

   1. 배포 구성에서 **Enter deployment configuration(배포 구성 입력)**을 선택합니다.

   1. **제품 ID**에 Service Catalog 콘솔에서 복사한 제품 ID를 붙여 넣습니다.

   1. **Template file path(템플릿 파일 경로)**에 템플릿 파일이 저장된 상대 경로를 입력합니다.

   1. **제품 유형**에서 **CloudFormation 템플릿**을 선택합니다.

   1. **제품 버전 이름**에 Service Catalog에서 지정한 제품 버전의 이름을 입력합니다. 템플릿 변경 사항을 새 제품 버전에 배포하려면 동일한 제품의 이전 제품 버전에 사용되지 않은 제품 버전 이름을 입력합니다.

   1. **입력 아티팩트**에 소스 입력 아티팩트를 선택합니다.

   1. **다음**을 선택합니다.

1. **7단계: 검토**에서 파이프라인 설정을 검토한 다음 **생성**를 선택합니다.

1. 파이프라인이 성공적으로 실행된 후 배포 단계에서 **세부 정보**를 선택합니다. 그러면 제품이 Service Catalog에서 열립니다.  
![\[\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/deploy-servicecatalog-pipeline.png)

1. 제품 정보에서 버전 이름을 선택하여 제품 템플릿을 엽니다. 템플릿 배포를 봅니다.

### 4단계: Service Catalog에서 변경 사항 푸시 및 제품 확인
<a name="tutorials-S3-servicecatalog-change"></a>

1. CodePipeline 콘솔의 파이프라인을 보고 소스 페이지에서 **세부 정보**를 선택합니다. 소스 AWS CodeCommit 리포지토리가 콘솔에서 열립니다. **편집**을 선택하고 파일에 대해 변경합니다(예: 설명 변경).

   ```
   "Description": "Name of Amazon S3 bucket to hold and version website content"
   ```

1. 변경 사항을 커밋하고 푸시합니다. 변경 사항을 푸시한 후 파이프라인이 시작됩니다. 파이프라인 실행이 완료되면 배포 단계에서 **세부 정보**를 선택하여 Service Catalog에서 제품을 엽니다.

1. 제품 정보에서 새 버전 이름을 선택하여 제품 템플릿을 엽니다. 배포된 템플릿 변경 사항을 봅니다.

## 옵션 2: 구성 파일을 사용하여 Service Catalog에 배포
<a name="tutorials-S3-servicecatalog-ex2-configure"></a>

이 예제에서는 S3 버킷에 대한 샘플 AWS CloudFormation 템플릿 파일을 업로드한 다음 Service Catalog에서 제품을 생성합니다. 또한 배포 구성을 지정하는 별도의 구성 파일을 업로드합니다. 그런 다음 파이프 라인을 생성하고 구성 파일의 위치를 지정합니다.

### 1단계: 샘플 템플릿 파일을 소스 리포지토리에 업로드
<a name="tutorials-S3-servicecatalog-upload2"></a>

1. 텍스트 편집기를 엽니다. 다음을 파일에 붙여 넣고 샘플 템플릿을 생성합니다. 파일을 `S3_template.json`(으)로 저장합니다.

   ```
   {
     "AWSTemplateFormatVersion": "2010-09-09",
     "Description": "CloudFormation Sample Template S3_Bucket: Sample template showing how to create a privately accessible S3 bucket. **WARNING** This template creates an S3 bucket. You will be billed for the resources used if you create a stack from this template.",
     "Resources": {
       "S3Bucket": {
         "Type": "AWS::S3::Bucket",
         "Properties": {}
       }
     },
     "Outputs": {
       "BucketName": {
         "Value": {
           "Ref": "S3Bucket"
         },
         "Description": "Name of Amazon S3 bucket to hold website content"
       }
     }
   }
   ```

   이 템플릿을 사용하면가 Service Catalog에서 사용할 수 있는 S3 버킷을 AWS CloudFormation 생성할 수 있습니다.

1.  AWS CodeCommit 리포지토리에 `S3_template.json` 파일을 업로드합니다.

### 2단계: 제품 배포 구성 파일 생성
<a name="tutorials-S3-servicecatalog-configure2"></a>

1. 텍스트 편집기를 엽니다. 제품의 구성 파일을 생성합니다. 구성 파일은 Service Catalog 배포 파라미터/기본 설정을 정의하는 데 사용됩니다. 이 파일은 파이프라인을 생성할 때 사용합니다.

   이 샘플은 "devops S3 v2"의 `ProductVersionName` 및 `MyProductVersionDescription`의 `ProductVersionDescription`을 제공합니다. 템플릿 변경 사항을 새 제품 버전에 배포하려면 동일한 제품의 이전 제품 버전에 사용되지 않은 제품 버전 이름을 입력합니다.

    파일을 `sample_config.json`(으)로 저장합니다.

   ```
   {
       "SchemaVersion": "1.0",
       "ProductVersionName": "devops S3 v2",
       "ProductVersionDescription": "MyProductVersionDescription",
       "ProductType": "CLOUD_FORMATION_TEMPLATE",
       "Properties": {
           "TemplateFilePath": "/S3_template.json"
       }
   }
   ```

   이 파일은 파이프라인이 실행될 때마다 제품 버전 정보를 생성합니다.

1.  AWS CodeCommit 리포지토리에 `sample_config.json` 파일을 업로드합니다. 이 파일을 소스 리포지토리에 업로드했는지 확인합니다.

### 3단계: Service Catalog에서 제품 생성
<a name="tutorials-S3-servicecatalog-product2"></a>

1. IT 관리자로 Service Catalog 콘솔에 로그인하고 **제품** 페이지로 이동한 다음 **제품 신규 업로드**를 선택합니다.

1. **제품 신규 업로드** 페이지에서 다음 작업을 완료합니다.

   1. **제품 이름**에 새 제품에 사용할 이름을 입력합니다.

   1. **설명**에 제품 카탈로그 설명을 입력합니다. 이 설명은 사용자가 올바른 제품을 선택할 수 있도록 제품 목록에 표시됩니다.

   1. **공급자** - IT 부서 또는 관리자의 이름을 입력합니다.

   1. **다음**을 선택합니다.

1. (선택 사항) **지원 세부 정보 입력** 페이지에서 제품 지원 연락처 정보를 입력하고 **다음**을 선택합니다.

1. **버전 세부 정보**에서 다음을 완료합니다.

   1. **템플릿 파일 업로드**를 선택합니다. `S3_template.json` 파일을 찾고 업로드합니다.

   1. **버전 제목** - 제품 버전의 이름을 입력합니다(예: "devops S3 v2").

   1. **설명**에서 이 버전을 다른 버전과 구별하는 세부 정보를 입력합니다.

   1. **다음**을 선택합니다.

1. **검토** 페이지에서 정보가 올바른지 확인한 후 **Confirm and upload(확인 및 업로드)**를 선택합니다.

1. **제품** 페이지의 브라우저에서 새 제품의 URL을 복사합니다. 이는 제품 ID를 포함합니다. 이 제품 ID를 복사하여 보관합니다. CodePipeline에서 파이프라인을 생성할 때 사용합니다.

   다음은 `my-product` 제품의 URL입니다. 제품 ID를 추출하려면 등호 기호(`=`) 및 앰퍼샌드(`&`) 사이의 값을 복사합니다. 이 예시에서의 제품 ID는 `prod-example123456`입니다.

   ```
   https://<region-URL>/servicecatalog/home?region=<region>#/admin-products?productCreated=prod-example123456&createdProductTitle=my-product
   ```
**참고**  
페이지에서 벗어나기 전에 제품의 URL을 복사합니다. 이 페이지를 벗어난 후 CLI를 사용하여 제품 ID를 얻어야 합니다.

   몇 초 후 **제품** 페이지에 제품이 표시됩니다. 목록의 제품을 보기 위해 브라우저를 새로 고쳐야 할 수도 있습니다.

### 4단계: 파이프라인 생성
<a name="tutorials-S3-servicecatalog-pipeline2"></a>

1. 파이프라인에 이름을 지정하고 파이프라인에 대한 파라미터를 선택하려면 다음을 수행합니다.

   1. 에 로그인 AWS Management Console 하고 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) CodePipeline 콘솔을 엽니다.

   1. **시작하기**를 선택합니다. **파이프라인 생성**을 선택한 다음 파이프라인의 이름을 입력합니다.

   1. **서비스 역할**에서 **새 서비스 역할**을 선택하여CodePipeline이 IAM에 서비스 역할을 생성하도록 허용합니다.

   1. [**Advanced settings**]의 설정은 기본값 그대로 두고, [**Next**]를 선택합니다.

1. 소스 단계를 추가하려면 다음을 수행합니다.

   1. **소스 공급자**에서 **AWS CodeCommit**을 선택합니다.

   1. **리포지토리 이름** 및 **브랜치 이름**에서 소스 작업에 사용할 리포지토리와 브랜치를 입력합니다.

   1. **다음**을 선택합니다.

1. **Add build stage(빌드 단계 추가)**에서 **Skip build stage(빌드 단계 건너뛰기)**를 선택하고 **Skip(건너뛰기)**을 다시 선택하여 경고 메시지를 수락합니다.

1. **Add deploy stage(배포 단계 추가)**에서 다음을 완료합니다.

   1. **Deploy provider(배포 공급자)**에서 **AWS Service Catalog**를 선택합니다.

   1. **Use configuration file(구성 파일 사용)**을 선택합니다.

   1. **제품 ID**에 Service Catalog 콘솔에서 복사한 제품 ID를 붙여 넣습니다.

   1. **Configuration file path(구성 파일 경로)**에서 리포지토리의 구성 파일 경로를 입력합니다.

   1. **다음**을 선택합니다.

1. **Review(검토)**에서 파이프라인 설정을 검토한 다음 **Create(생성)**를 선택합니다.

1. 파이프라인이 성공적으로 실행된 후 배포 단계에서 **세부 정보**를 선택하여 Service Catalog에서 제품을 엽니다.  
![\[\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/deploy-servicecatalog-pipeline.png)

1. 제품 정보에서 버전 이름을 선택하여 제품 템플릿을 엽니다. 템플릿 배포를 봅니다.

### 5단계: Service Catalog에서 변경 사항 푸시 및 제품 확인
<a name="tutorials-S3-servicecatalog-change2"></a>

1. CodePipeline 콘솔의 파이프라인을 보고 소스 페이지에서 **세부 정보**를 선택합니다. 소스 AWS CodeCommit 리포지토리가 콘솔에서 열립니다. **편집**을 선택한 다음 파일에 대해 변경합니다(예: 설명 변경).

   ```
   "Description": "Name of Amazon S3 bucket to hold and version website content"
   ```

1. 변경 사항을 커밋하고 푸시합니다. 변경 사항을 푸시한 후 파이프라인이 시작됩니다. 파이프라인 실행이 완료되면 배포 단계에서 **세부 정보**를 선택하여 Service Catalog에서 제품을 엽니다.

1. 제품 정보에서 새 버전 이름을 선택하여 제품 템플릿을 엽니다. 배포된 템플릿 변경 사항을 봅니다.

# 자습서:를 사용하여 파이프라인 생성 AWS CloudFormation
<a name="tutorials-cloudformation"></a>

이 예제에서는를 사용하여 소스 코드가 변경될 때마다 인스턴스 AWS CloudFormation 에 애플리케이션을 배포하는 파이프라인을 생성할 수 있는 샘플 템플릿을 제공합니다. 샘플 템플릿은 AWS CodePipeline에서 볼 수 있는 파이프라인을 생성합니다. 파이프라인은 Amazon CloudWatch Events를 통해 저장된 변경 사항의 도착을 감지합니다.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

**Topics**
+ [예제 1:를 사용하여 AWS CodeCommit 파이프라인 생성 AWS CloudFormation](tutorials-cloudformation-codecommit.md)
+ [예제 2:를 사용하여 Amazon S3 파이프라인 생성 AWS CloudFormation](tutorials-cloudformation-s3.md)

# 예제 1:를 사용하여 AWS CodeCommit 파이프라인 생성 AWS CloudFormation
<a name="tutorials-cloudformation-codecommit"></a>

이 연습에서는 AWS CloudFormation 콘솔을 사용하여 CodeCommit 소스 리포지토리에 연결된 파이프라인을 포함하는 인프라를 생성하는 방법을 보여줍니다. 이 자습서에서는 제공된 샘플 템플릿 파일을 사용하여 아티팩트 스토어, 파이프라인 및 Amazon CloudWatch Events 규칙과 같은 변경 감지 리소스가 포함된 리소스 스택을 생성합니다. 에서 리소스 스택을 생성한 후 AWS CodePipeline 콘솔에서 파이프라인을 볼 AWS CloudFormation수 있습니다. 파이프라인은 CodeCommit 소스 단계와 CodeDeploy 배포 단계가 있는 2단계 파이프라인입니다.

**사전 조건**:

 AWS CloudFormation 샘플 템플릿과 함께 사용하려면 다음 리소스를 생성해야 합니다.
+ 소스 리포지토리가 생성되어 있어야 합니다. 에서 생성한 AWS CodeCommit 리포지토리를 사용할 수 있습니다[자습서: 간단한 파이프라인 생성(CodeCommit 리포지토리)](tutorials-simple-codecommit.md).
+ CodeDeploy 애플리케이션 및 배포 그룹을 생성해야 합니다. [자습서: 간단한 파이프라인 생성(CodeCommit 리포지토리)](tutorials-simple-codecommit.md)에 생성한 CodeDeploy 리소스를 사용할 수 있습니다.
+ 다음 링크 중 하나를 선택하여 파이프라인 생성을 위한 샘플 AWS CloudFormation 템플릿 파일을 다운로드합니다. [YAML](samples/codepipeline-codecommit-events-yaml.zip) \$1 [JSON](samples/codepipeline-codecommit-events-json.zip)

  파일의 압축을 풀고 로컬 컴퓨터에 저장합니다.
+ [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip) 샘플 애플리케이션 파일을 다운로드합니다.



**에서 파이프라인 생성 AWS CloudFormation**

1. [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip)에서 파일의 압축을 풀고 AWS CodeCommit 리포지토리에 파일을 업로드합니다. 압축을 푼 파일을 리포지토리의 루트 디렉터리에 업로드해야 합니다. [2단계: CodeCommit 리포지토리에 샘플 코드 추가](tutorials-simple-codecommit.md#codecommit-add-code)의 지침에 따라 파일을 리포지토리로 푸시할 수 있습니다.

1.  AWS CloudFormation 콘솔을 열고 **스택 생성을** 선택합니다. **새 리소스 사용(표준)(With new resources (standard))**을 선택합니다.

1. **템플릿 지정**에서 **템플릿 업로드**를 선택합니다. **파일 선택**을 선택한 후 로컬 컴퓨터에서 템플릿 파일을 선택합니다. **다음**을 선택합니다.

1. **스택 이름**에 파이프라인의 이름을 입력합니다. 샘플 템플릿에 지정된 파라미터가 표시됩니다. 다음 파라미터를 입력합니다.

   1. **ApplicationName**에 CodeDeploy 애플리케이션의 이름을 입력합니다.

   1. **BetaFleet**에 CodeDeploy 배포 그룹 이름을 입력합니다.

   1. **BranchName**에서 사용할 리포지토리 브랜치를 입력합니다.

   1. **RepositoryName**에서 CodeCommit 소스 리포지토리의 이름을 입력합니다.

1. **다음**을 선택합니다. 다음 페이지에서 기본값을 적용한 후 **다음**을 선택합니다.

1. **기능**에서 **이 IAM 리소스를 생성할 AWS CloudFormation 수 있음을 승인합니다**를 선택한 다음 **스택 생성을** 선택합니다.

1. 스택 생성을 완료한 후 이벤트 목록에서 오류를 확인합니다.

   **문제 해결**

   에서 파이프라인을 생성하는 IAM 사용자는 파이프라인에 대한 리소스를 생성하는 데 추가 권한이 필요할 AWS CloudFormation 수 있습니다. 가 CodeCommit 파이프라인에 필요한 Amazon CloudWatch Events 리소스를 AWS CloudFormation 생성하도록 허용하려면 정책에 다음 권한이 필요합니다.

   ```
   {
        "Effect": "Allow",
        "Action": [
           "events:PutRule",
           "events:PutEvents",
           "events:PutTargets",
           "events:DeleteRule",
           "events:RemoveTargets",
           "events:DescribeRule"
        ],
        "Resource": "resource_ARN"
   }
   ```

1. 에 로그인 AWS Management Console 하고 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) CodePipeline 콘솔을 엽니다.

   **파이프라인**에서 파이프라인을 선택하고 **보기**를 선택합니다. 다이어그램은 파이프라인 소스 및 배포 단계를 보여줍니다.
**참고**  
생성된 파이프라인을 보려면 CloudFormation의 스택에 대한 **리소스** 탭에서 **논리적 ID** 열을 찾으세요. 파이프라인의 **물리적 ID** 열에 있는 이름을 기록해 둡니다. CodePipeline에서는 스택을 생성한 리전의 동일한 물리적 ID(파이프라인 이름)로 파이프라인을 볼 수 있습니다.

1. 소스 리포지토리에서 변경 사항을 커밋하고 푸시합니다. 변경 감지 리소스가 변경 사항을 선택하면 파이프라인이 시작됩니다.

# 예제 2:를 사용하여 Amazon S3 파이프라인 생성 AWS CloudFormation
<a name="tutorials-cloudformation-s3"></a>

이 연습에서는 AWS CloudFormation 콘솔을 사용하여 Amazon S3 소스 버킷에 연결된 파이프라인을 포함하는 인프라를 생성하는 방법을 보여줍니다. 샘플 템플릿 파일을 사용하여 소스 버킷, 아티팩트 스토어, 파이프라인 및 Amazon CloudWatch Events 규칙 및 CloudTrail 추적과 같은 변경 감지 리소스가 포함된 리소스 스택을 만듭니다. 에서 리소스 스택을 생성한 후 AWS CodePipeline 콘솔에서 파이프라인을 볼 AWS CloudFormation수 있습니다. 파이프라인은 Amazon S3 소스 단계와 CodeDeploy 배포 단계가 있는 2단계 파이프라인입니다.

**사전 조건**:

 AWS CloudFormation 샘플 템플릿과 함께 사용하려면 다음 리소스가 있어야 합니다.
+ 인스턴스에 CodeDeploy 에이전트를 설치한 Amazon EC2 인스턴스를 생성해야 합니다. CodeDeploy 애플리케이션 및 배포 그룹을 생성해야 합니다. [자습서: 간단한 파이프라인 생성(CodeCommit 리포지토리)](tutorials-simple-codecommit.md)에 생성한 Amazon EC2 및 CodeDeploy 리소스를 사용합니다.
+ 다음 링크를 선택하여 Amazon S3 소스로 파이프라인을 생성하기 위한 샘플 AWS CloudFormation 템플릿 파일을 다운로드합니다.
  + 파이프라인에 대한 샘플 템플릿을 [YAML](samples/codepipeline-s3-events-yaml.zip) 또는 [JSON](samples/codepipeline-s3-events-json.zip) 형식으로 다운로드합니다.
  + CloudTrail 버킷 및 추적을 위한 샘플 템플릿([YAML](samples/codepipeline-s3-cloudtrail-yaml.zip) \$1 [JSON](samples/codepipeline-s3-cloudtrail-json.zip) 형식)을 다운로드합니다.
  + 파일의 압축을 풀고 로컬 컴퓨터에 저장합니다.
+ [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip) 샘플 애플리케이션 파일을 다운로드합니다.

  zip 파일을 로컬 컴퓨터에 저장합니다. 스택을 만든 후에 zip 파일을 업로드합니다.

**에서 파이프라인 생성 AWS CloudFormation**

1.  AWS CloudFormation 콘솔을 열고 **스택 생성을** 선택합니다. **새 리소스 사용(표준)(With new resources (standard))**을 선택합니다.

1. **템플릿 선택** 페이지에서 **템플릿 업로드**를 선택합니다. **파일 선택**을 선택한 후 로컬 컴퓨터에서 템플릿 파일을 선택합니다. **다음**을 선택합니다.

1. **스택 이름**에 파이프라인의 이름을 입력합니다. 샘플 템플릿에 지정된 파라미터가 표시됩니다. 다음 파라미터를 입력합니다.

   1. **ApplicationName**에 CodeDeploy 애플리케이션의 이름을 입력합니다. `DemoApplication` 기본 이름을 바꿀 수 있습니다.

   1. **BetaFleet**에 CodeDeploy 배포 그룹 이름을 입력합니다. `DemoFleet` 기본 이름을 바꿀 수 있습니다.

   1. **SourceObjectKey**에서 `SampleApp_Linux.zip`을 입력합니다. 이 파일은 템플릿에서 버킷과 파이프라인을 생성하는 즉시 버킷에 업로드됩니다.

1. **다음**을 선택합니다. 다음 페이지에서 기본값을 적용한 후 **다음**을 선택합니다.

1. **기능**에서 **이 IAM 리소스를 생성할 AWS CloudFormation 수 있음을 승인합니다**를 선택한 다음 **스택 생성을** 선택합니다.

1. 스택 생성을 완료한 후 이벤트 목록에서 오류를 확인합니다.

   **문제 해결**

   에서 파이프라인을 생성하는 IAM 사용자는 파이프라인에 대한 리소스를 생성하는 데 추가 권한이 필요할 AWS CloudFormation 수 있습니다. 가 Amazon S3 파이프라인에 필요한 Amazon CloudWatch Events 리소스를 AWS CloudFormation 생성하도록 허용하려면 정책에 다음 권한이 필요합니다. Amazon S3 

   ```
   {
        "Effect": "Allow",
        "Action": [
           "events:PutRule",
           "events:PutEvents",
           "events:PutTargets",
           "events:DeleteRule",
           "events:RemoveTargets",
           "events:DescribeRule"
        ],
        "Resource": "resource_ARN"
   }
   ```

1. 의 스택 CloudFormation에 대한 **리소스** 탭에서 스택에 대해 생성된 리소스를 확인합니다.
**참고**  
생성된 파이프라인을 보려면 CloudFormation의 스택에 대한 **리소스** 탭에서 **논리적 ID** 열을 찾으세요. 파이프라인의 **물리적 ID** 열에 있는 이름을 기록해 둡니다. CodePipeline에서는 스택을 생성한 리전의 동일한 물리적 ID(파이프라인 이름)로 파이프라인을 볼 수 있습니다.

   이름에 `sourcebucket` 레이블이 있는 S3 버킷을 선택합니다(예: `s3-cfn-codepipeline-sourcebucket-y04EXAMPLE.`). 파이프라인의 아티팩트 버킷을 선택하지 않습니다.

   리소스가 CloudFormation에서 새로 생성되었으므로 원본 버킷이 비어 있습니다. Amazon S3 콘솔을 열고 `sourcebucket` 버킷을 선택합니다. **업로드**를 선택하고 지침에 따라 `SampleApp_Linux.zip` .zip 파일을 업로드합니다.
**참고**  
Amazon S3가 파이프라인의 소스 공급자인 경우, 단일 .zip 파일로 패키지된 모든 소스 파일을 버킷에 업로드해야 합니다. 그렇지 않으면 소스 작업이 실패합니다.

1. 에 로그인 AWS Management Console 하고 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) CodePipeline 콘솔을 엽니다.

   **파이프라인**에서 파이프라인을 선택한 후 **보기**를 선택합니다. 다이어그램은 파이프라인 소스 및 배포 단계를 보여줍니다.

1. 다음 절차의 단계를 완료하여 AWS CloudTrail 리소스를 생성합니다.

**에서 AWS CloudTrail 리소스 생성 AWS CloudFormation**

1.  AWS CloudFormation 콘솔을 열고 **스택 생성을** 선택합니다.

1. **템플릿 선택** 페이지에서 **Amazon S3에 템플릿 업로드**를 선택합니다. **찾아보**기를 선택한 다음 로컬 컴퓨터의 AWS CloudTrail 리소스에 대한 템플릿 파일을 선택합니다. **다음**을 선택합니다.

1. **스택 이름**에 리소스 스택의 이름을 입력합니다. 샘플 템플릿에 지정된 파라미터가 표시됩니다. 다음 파라미터를 입력합니다.

   1. **SourceObjectKey**에서 샘플 애플리케이션의 zip 파일에 대한 기본값을 적용합니다.

1. **다음**을 선택합니다. 다음 페이지에서 기본값을 적용한 후 **다음**을 선택합니다.

1. **기능**에서 **이 IAM 리소스를 생성할 AWS CloudFormation 수 있음을 승인합니다**를 선택한 다음 **생성을** 선택합니다.

1. 스택 생성을 완료한 후 이벤트 목록에서 오류를 확인합니다.

   가 Amazon S3 파이프라인에 필요한 CloudTrail 리소스를 AWS CloudFormation 생성하도록 허용하려면 정책에 다음 권한이 필요합니다.

   ```
   {
        "Effect": "Allow",
        "Action": [
           "cloudtrail:CreateTrail",
           "cloudtrail:DeleteTrail",
           "cloudtrail:StartLogging",
           "cloudtrail:StopLogging",
           "cloudtrail:PutEventSelectors"
        ],
        "Resource": "resource_ARN"
   }
   ```

1. 에 로그인 AWS Management Console 하고 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) CodePipeline 콘솔을 엽니다.

   **파이프라인**에서 파이프라인을 선택한 후 **보기**를 선택합니다. 다이어그램은 파이프라인 소스 및 배포 단계를 보여줍니다.

1. 소스 버킷에서 변경 사항을 커밋하고 푸시합니다. 변경 감지 리소스가 변경 사항을 선택하면 파이프라인이 시작됩니다.

# 자습서: AWS CloudFormation 배포 작업의 변수를 사용하는 파이프라인 생성
<a name="tutorials-cloudformation-action"></a>

이 자습서에서는 AWS CodePipeline 콘솔을 사용하여 배포 작업이 있는 파이프라인을 생성합니다. 파이프라인이 실행되면 템플릿은 스택을 생성하고 `outputs` 파일도 생성합니다. 스택 템플릿에 의해 생성된 출력은 CodePipeline의 AWS CloudFormation 작업에 의해 생성된 변수입니다.

템플릿에서 스택을 생성하는 작업에서 변수 네임스페이스를 지정합니다. 그런 다음 `outputs` 파일에 의해 생성된 변수는 후속 작업에서 사용할 수 있습니다. 이 예제에서는 AWS CloudFormation 작업에서 생성된 `StackName` 변수를 기반으로 변경 세트를 생성합니다. 수동 승인 후 변경 세트를 실행한 다음 `StackName` 변수를 기반으로 스택을 삭제하는 스택 삭제 작업을 생성합니다.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

**Topics**
+ [사전 조건: AWS CloudFormation 서비스 역할 및 CodeCommit 리포지토리 생성](#tutorials-cloudformation-action-prereq)
+ [1단계: 샘플 AWS CloudFormation 템플릿 다운로드, 편집 및 업로드](#tutorials-cloudformation-action-upload)
+ [2단계: 파이프라인 생성](#tutorials-cloudformation-action-pipeline)
+ [3단계: CloudFormation 배포 작업을 추가하여 변경 세트 생성](#tutorials-cloudformation-action-changeset)
+ [4단계: 수동 승인 작업 추가](#tutorials-cloudformation-action-approval)
+ [5단계: CloudFormation 배포 작업을 추가하여 변경 세트 실행](#tutorials-cloudformation-action-deployment)
+ [6단계: CloudFormation 배포 작업을 추가하여 스택 삭제](#tutorials-cloudformation-action-delete)

## 사전 조건: AWS CloudFormation 서비스 역할 및 CodeCommit 리포지토리 생성
<a name="tutorials-cloudformation-action-prereq"></a>

다음 항목이 있어야 합니다.
+ CodeCommit 리포지토리. 에서 생성한 AWS CodeCommit 리포지토리를 사용할 수 있습니다[자습서: 간단한 파이프라인 생성(CodeCommit 리포지토리)](tutorials-simple-codecommit.md).
+ 이 예제에서는 템플릿에서 Amazon DocumentDB 스택을 생성합니다. Amazon DocumentDB에 대한 다음 권한이 있는 AWS CloudFormation 서비스 역할을 생성하려면 AWS Identity and Access Management (IAM)을 사용해야 합니다.

  ```
  "rds:DescribeDBClusters",
  "rds:CreateDBCluster",
  "rds:DeleteDBCluster",
  "rds:CreateDBInstance"
  ```

## 1단계: 샘플 AWS CloudFormation 템플릿 다운로드, 편집 및 업로드
<a name="tutorials-cloudformation-action-upload"></a>

샘플 AWS CloudFormation 템플릿 파일을 다운로드하여 CodeCommit 리포지토리에 업로드합니다.

1. 해당 리전의 샘플 템플릿으로 이동합니다. 예를 들어 [https://docs.aws.amazon.com/documentdb/latest/developerguide/quick_start_cfn.html#quick_start_cfn-launch_stack](https://docs.aws.amazon.com/documentdb/latest/developerguide/quick_start_cfn.html#quick_start_cfn-launch_stack)의 테이블을 사용하여 리전을 선택하고 템플릿을 다운로드합니다. Amazon DocumentDB 클러스터클러스터용 템플릿을 다운로드하세요. 파일 이름은 `documentdb_full_stack.yaml`입니다.

1. `documentdb_full_stack.yaml` 파일의 압축을 풀고 텍스트 편집기에서 엽니다. 다음과 같이 변경합니다.

   1. 이 예제에서는 템플릿의 `Parameters` 섹션에 다음 `Purpose:` 파라미터를 추가합니다.

      ```
        Purpose:
          Type: String
          Default: testing
          AllowedValues:
            - testing
            - production
          Description: The purpose of this instance.
      ```

   1. 이 예제에서는 템플릿의 `Outputs:` 섹션에 다음 `StackName` 출력을 추가합니다.

      ```
        StackName:
          Value: !Ref AWS::StackName
      ```

1. 템플릿 파일을 AWS CodeCommit 리포지토리에 업로드합니다. 압축을 풀고 편집한 템플릿 파일을 리포지토리의 루트 디렉터리에 업로드해야 합니다.

   CodeCommit 콘솔을 사용하여 파일을 업로드하려면 다음과 같이 합니다.

   1. CodeCommit 콘솔을 열고 **리포지토리** 목록에서 해당 리포지토리를 선택합니다.

   1. **파일 추가**를 선택한 후 **파일 업로드**를 선택합니다.

   1. **파일 선택**을 선택한 다음 파일을 찾습니다. 사용자 이름과 이메일 주소를 입력하여 변경 사항을 커밋합니다. **변경 사항 커밋**을 선택합니다.

   파일은 리포지토리의 루트 수준에서 다음과 같아야 합니다.

   ```
   documentdb_full_stack.yaml
   ```

## 2단계: 파이프라인 생성
<a name="tutorials-cloudformation-action-pipeline"></a>

이 단원에서는 다음 작업을 통해 파이프라인을 생성합니다.
+ 소스 아티팩트가 템플릿 파일인 CodeCommit 작업이 있는 소스 단계입니다.
+ 배포 작업이 있는 CloudFormation 배포 단계입니다.

마법사가 생성한 소스 및 배포 단계의 각 작업에는 각각 변수 네임스페이스 `SourceVariables` 및 `DeployVariables`가 할당됩니다. 작업에 네임스페이스가 할당되어 있으므로 이 예제에 구성된 변수를 다운스트림 작업에 사용할 수 있습니다. 자세한 내용은 [변수 참조](reference-variables.md) 단원을 참조하십시오.

**마법사를 사용하여 파이프라인을 생성하려면**

1. 에 로그인 AWS Management Console 하고 [http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) CodePipeline 콘솔을 엽니다.

1. [**Welcome**] 페이지, [**Getting started**] 페이지 또는 [**Pipelines**] 페이지에서 **Create pipeline(파이프라인 생성)**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 **MyCFNDeployPipeline**을 입력합니다.

1. CodePipeline은 특성과 가격이 다른 V1 및 V2 유형 파이프라인을 제공합니다. V2 유형은 콘솔에서 선택할 수 있는 유일한 유형입니다. 자세한 내용은 [파이프라인 유형](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)을 참조하세요. CodePipeline에 대한 요금 정보는 [요금](https://aws.amazon.com/codepipeline/pricing/)을 참조하세요.

1. **서비스 역할**에서 다음 중 하나를 수행합니다.
   + **새 서비스 역할**을 선택하여 CodePipeline이 IAM에 서비스 역할을 생성하도록 허용합니다.
   + **Existing service role(기존 서비스 역할)**을 선택합니다. **역할 이름**의 목록에서 서비스 역할을 선택합니다.

1. **아티팩트 스토어**에서 다음과 같이 합니다.

   1. 파이프라인에 대해 선택한 리전의 파이프라인에 기본값으로 지정된 Amazon S3 아티팩트 버킷과 같은 기본 아티팩트 스토어를 사용하려면 **기본 위치**를 선택합니다.

   1. 파이프라인과 동일한 리전에 Amazon S3 아티팩트 버킷과 같이 이미 아티팩트 스토어가 있는 경우 **사용자 지정 위치**을 선택합니다.
**참고**  
이는 소스 코드에 대한 소스 버킷이 아닙니다. 이 파이프라인은 아티팩트 스토어입니다. S3 버킷과 같은 개별 아티팩트 스토어는 각 파이프라인에 필요합니다. 파이프라인을 생성하거나 편집할 때는 파이프라인 리전에 아티팩트 버킷이 있고 작업을 실행하는 AWS 리전당 하나의 아티팩트 버킷이 있어야 합니다.  
자세한 내용은 [입력 및 출력 아티팩트](welcome-introducing-artifacts.md) 및 [CodePipeline 파이프라인 구조 참조](reference-pipeline-structure.md) 섹션을 참조하세요.

   **다음**을 선택합니다.

1. **3단계: 소스 스테이지 추가**에서 다음과 같이 합니다.

   1. **소스 공급자**에서 **AWS CodeCommit**을 선택합니다.

   1. **리포지토리 이름**에서 [1단계: CodeCommit 리포지토리 생성](tutorials-simple-codecommit.md#codecommit-create-repository)에서 생성한 CodeCommit 리포지토리의 이름을 선택합니다.

   1. [**Branch name**]에서 가장 마지막 코드 업데이트가 포함된 브랜치의 이름을 선택합니다.

   리포지토리 이름과 브랜치를 선택하면 이 파이프라인에 대해 생성될 Amazon CloudWatch Events 규칙이 표시됩니다.

   **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가**에서 **빌드 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **6단계: 배포 단계 추가**에서:

   1. **작업 이름**에서 **배포**를 선택합니다. **배포 공급자**에서 **CloudFormation**을 선택합니다.

   1. **작업 모드**에서 **스택 생성 또는 업데이트**를 선택합니다.

   1. **스택 이름**에 스택의 이름을 입력합니다. 템플릿이 생성하는 스택의 이름입니다.

   1. **출력 파일 이름**에 출력 파일의 이름(예: **outputs**)을 입력합니다. 스택이 생성된 후 작업에 의해 생성되는 파일의 이름입니다.

   1. **고급**을 확장합니다. **매개변수 재정의**에서 템플릿 재정의를 키-값 쌍으로 입력합니다. 예를 들어 이 템플릿에는 다음과 같은 재정의가 필요합니다.

      ```
      {
      "DBClusterName": "MyDBCluster",
      "DBInstanceName": "MyDBInstance",
      "MasterUser": "UserName",
      "MasterPassword": "Password",
      "DBInstanceClass": "db.r4.large",
      "Purpose": "testing"}
      ```

      재정의를 입력하지 않으면 템플릿에서 기본값으로 스택을 생성합니다.

   1. **다음**을 선택합니다.

   1. **7단계: 검토**에서 **파이프라인 생성을** 선택합니다. 파이프라인 스테이지를 보여주는 다이어그램을 확인해야 합니다. 파이프라인이 실행되도록 허용합니다. 2단계 파이프라인이 완료되어 단계를 추가할 준비가 되었습니다.

## 3단계: CloudFormation 배포 작업을 추가하여 변경 세트 생성
<a name="tutorials-cloudformation-action-changeset"></a>

파이프라인에서 수동 승인 작업 전에가 변경 세트를 CloudFormation 생성할 수 있는 다음 작업을 생성합니다.



1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔을 엽니다.

   **파이프라인**에서 파이프라인을 선택하고 **보기**를 선택합니다. 다이어그램은 파이프라인 소스 및 배포 단계를 보여줍니다.

1. 파이프라인을 편집하거나 **편집** 모드에서 파이프라인을 계속 표시합니다.

1. **배포 **단계를 편집하려면 선택합니다.

1. 이전 작업에서 생성된 스택에 대한 변경 세트를 생성하는 배포 작업을 추가합니다. 단계의 기존 작업 뒤에 이 작업을 추가합니다.

   1. **작업 이름**에 **Change\$1Set**를 입력합니다. **작업 공급자**에서 **AWS CloudFormation **을 선택합니다.

   1. **입력 아티팩트**에서 **SourceArtifact**를 선택합니다.

   1. **작업 모드**에서 **변경 사항 세트 생성 또는 교체**를 선택합니다.

   1. **스택 이름**에 다음과 같이 변수 구문을 입력합니다. 변경 세트가 생성되는 스택의 이름입니다. 여기서 기본 네임스페이스 `DeployVariables`는 작업에 할당됩니다.

      ```
      #{DeployVariables.StackName}
      ```

   1. **변경 세트 이름**에서 변경 세트의 이름을 입력합니다.

      ```
      my-changeset
      ```

   1. **파라미터 재정의**에서 `Purpose` 파라미터를 `testing`에서 `production`으로 변경합니다.

      ```
      {
      "DBClusterName": "MyDBCluster",
      "DBInstanceName": "MyDBInstance",
      "MasterUser": "UserName",
      "MasterPassword": "Password",
      "DBInstanceClass": "db.r4.large",
      "Purpose": "production"}
      ```

   1. **완료**를 선택하여 작업을 저장합니다.

## 4단계: 수동 승인 작업 추가
<a name="tutorials-cloudformation-action-approval"></a>

파이프라인에서 수동 승인 작업을 생성합니다.



1. 파이프라인을 편집하거나 **편집** 모드에서 파이프라인을 계속 표시합니다.

1. **배포 **단계를 편집하려면 선택합니다.

1. 변경 세트를 생성하는 배포 작업 다음에 수동 승인 작업을 추가합니다. 이 작업을 사용하면 파이프라인이 변경 세트를 실행하기 CloudFormation 전에에서 생성된 리소스 변경 세트를 확인할 수 있습니다.

## 5단계: CloudFormation 배포 작업을 추가하여 변경 세트 실행
<a name="tutorials-cloudformation-action-deployment"></a>

파이프라인에서 수동 승인 작업 후가 변경 세트를 CloudFormation 실행할 수 있는 다음 작업을 생성합니다.



1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔을 엽니다.

   **파이프라인**에서 파이프라인을 선택하고 **보기**를 선택합니다. 다이어그램은 파이프라인 소스 및 배포 단계를 보여줍니다.

1. 파이프라인을 편집하거나 **편집** 모드에서 파이프라인을 계속 표시합니다.

1. **배포 **단계를 편집하려면 선택합니다.

1. 이전 수동 작업에서 승인된 변경 세트를 실행할 배포 작업을 추가합니다.

   1. **작업 이름**에 **Execute\$1Change\$1Set**를 입력합니다. **작업 공급자**에서 **AWS CloudFormation**을 선택합니다.

   1. **입력 아티팩트**에서 **SourceArtifact**를 선택합니다.

   1. **작업 모드**에서 **변경 세트 실행**을 선택합니다.

   1. **스택 이름**에 다음과 같이 변수 구문을 입력합니다. 변경 세트가 생성되는 스택의 이름입니다.

      ```
      #{DeployVariables.StackName}
      ```

   1. **변경 세트 이름**에 이전 작업에서 생성한 변경 세트의 이름을 입력합니다.

      ```
      my-changeset
      ```

   1. **완료**를 선택하여 작업을 저장합니다.

   1. 파이프라인 실행을 계속합니다.

## 6단계: CloudFormation 배포 작업을 추가하여 스택 삭제
<a name="tutorials-cloudformation-action-delete"></a>

파이프라인에서 출력 파일의 변수에서 스택 이름을 CloudFormation 가져오고 스택을 삭제할 수 있는 최종 작업을 생성합니다.



1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔을 엽니다.

   **파이프라인**에서 파이프라인을 선택하고 **보기**를 선택합니다. 다이어그램은 파이프라인 소스 및 배포 단계를 보여줍니다.

1. 파이프라인을 편집하도록 선택합니다.

1. **배포 **단계를 편집하려면 선택합니다.

1. 스택을 삭제할 배포 작업을 추가합니다.

   1. **작업 이름**에서 **DeleteStack**을 선택합니다. **배포 공급자**에서 **CloudFormation**을 선택합니다.

   1. **작업 모드**에서 **스택 삭제**를 선택합니다.

   1. **스택 이름**에 다음과 같이 변수 구문을 입력합니다. 작업이 삭제하는 스택의 이름입니다.

   1. **완료**를 선택하여 작업을 저장합니다.

   1. **저장**을 선택하여 파이프라인을 저장합니다.

   파이프라인은 저장될 때 실행됩니다.

# 자습서: CodePipeline을 사용한 Amazon ECS 표준 배포
<a name="ecs-cd-pipeline"></a>

이 자습서에서는 CodePipeline을 통해 Amazon ECS를 사용하여 종단 간에 CD(Continuous Deployment) 파이프라인을 생성하는 방법을 설명합니다.

**중요**  
콘솔에서 파이프라인을 생성하는 과정에서 CodePipeline은 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

**참고**  
이 자습서는 CodePipeline의 Amazon ECS 표준 배포 작업에 대한 것입니다. CodePipeline의 Amazon ECS에서 CodeDeploy로의 블루/그린 배포 작업을 사용하는 자습서는 [자습서: Amazon ECR 소스 및 ECS-to-CodeDeploy 배포를 사용하여 파이프라인 생성](tutorials-ecs-ecr-codedeploy.md) 단원을 참조하세요.

**참고**  
이 자습서는 소스 작업이 포함된 CodePipeline용 Amazon ECS 표준 배포 작업에 관한 것입니다. Amazon ECSstandard 배포 작업과 함께 CodePipeline의 ECRBuildAndPublish 빌드 작업을 사용하여 이미지를 푸시하는 자습서는 [자습서: CodePipeline을 사용하여 Docker 이미지를 빌드하고 Amazon ECR에 푸시(V2 유형)](tutorials-ecr-build-publish.md) 섹션을 참조하세요.

## 사전 조건
<a name="ecs-cd-prereqs"></a>

이 자습서를 이용하여 CD 파이프라인을 만들려면 먼저 몇 가지 리소스를 갖춰야 합니다. 다음은 시작하기 위해 필요한 항목입니다.

**참고**  
이러한 모든 리소스는 동일한 AWS 리전 내에 생성되어야 합니다.
+ Dockerfile 및 애플리케이션 소스에 대한 소스 컨트롤 리포지토리(이 자습서에서는 CodeCommit 사용). 자세한 내용은 *AWS CodeCommit 사용 설명서*의 [CodeCommit 리포지토리 생성](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-create-repository.html)을 참조하세요.
+ Dockerfile 및 애플리케이션 소스에서 만든 이미지를 포함하는 도커 이미지 리포지토리(이 자습서에서는 Amazon ECR 사용). 자세한 내용은 *Amazon Elastic Container Registry 사용 설명서*의 [리포지토리 생성](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) 및 [이미지 푸시](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html)를 참조하세요.
+ 해당 이미지 리포지토리에서 호스팅되는 도커 이미지를 참조하는 Amazon ECS 작업 정의. 자세한 내용을 알아보려면 *Amazon Elastic Container Service 개발자 안내서*의 [작업 정의 생성](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-task-definition.html)을 참조하세요.
**중요**  
CodePipeline의 Amazon ECS 표준 배포 작업은 Amazon ECS 서비스에서 사용하는 수정 버전을 기반으로 작업 정의의 자체 수정 버전을 생성합니다. Amazon ECS 서비스를 업데이트하지 않고 작업 정의에 대한 새 수정 사항을 생성하면 배포 작업에서 해당 수정 사항을 무시합니다.

  다음은 이 자습서에서 사용된 샘플 태스크 정의입니다. `name` 및 `family`에 사용하는 값은 빌드 사양 파일의 다음 단계에서 사용됩니다.

  ```
  {
    "ipcMode": null,
    "executionRoleArn": "role_ARN",
    "containerDefinitions": [
      {
        "dnsSearchDomains": null,
        "environmentFiles": null,
        "logConfiguration": {
          "logDriver": "awslogs",
          "secretOptions": null,
          "options": {
            "awslogs-group": "/ecs/hello-world",
            "awslogs-region": "us-west-2",
            "awslogs-stream-prefix": "ecs"
          }
        },
        "entryPoint": null,
        "portMappings": [
          {
            "hostPort": 80,
            "protocol": "tcp",
            "containerPort": 80
          }
        ],
        "command": null,
        "linuxParameters": null,
        "cpu": 0,
        "environment": [],
        "resourceRequirements": null,
        "ulimits": null,
        "dnsServers": null,
        "mountPoints": [],
        "workingDirectory": null,
        "secrets": null,
        "dockerSecurityOptions": null,
        "memory": null,
        "memoryReservation": 128,
        "volumesFrom": [],
        "stopTimeout": null,
        "image": "image_name",
        "startTimeout": null,
        "firelensConfiguration": null,
        "dependsOn": null,
        "disableNetworking": null,
        "interactive": null,
        "healthCheck": null,
        "essential": true,
        "links": null,
        "hostname": null,
        "extraHosts": null,
        "pseudoTerminal": null,
        "user": null,
        "readonlyRootFilesystem": null,
        "dockerLabels": null,
        "systemControls": null,
        "privileged": null,
        "name": "hello-world"
      }
    ],
    "placementConstraints": [],
    "memory": "2048",
    "taskRoleArn": null,
    "compatibilities": [
      "EC2",
      "FARGATE"
    ],
    "taskDefinitionArn": "ARN",
    "family": "hello-world",
    "requiresAttributes": [],
    "pidMode": null,
    "requiresCompatibilities": [
      "FARGATE"
    ],
    "networkMode": "awsvpc",
    "cpu": "1024",
    "revision": 1,
    "status": "ACTIVE",
    "inferenceAccelerators": null,
    "proxyConfiguration": null,
    "volumes": []
  }
  ```
+ 앞에서 언급한 해당 작업 정의를 사용하는 서비스를 실행 중인 Amazon ECS 클러스터. 자세한 내용은 *Amazon Elastic Container Service 개발자 안내서*의 [클러스터 생성](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/clusters.html) 및 [서비스 생성](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-console-v2.html)을 참조하세요.

이러한 사전 조건을 모두 갖췄으면 이제 자습서를 이용하여 CD 파이프라인을 만들 수 있습니다.

## 1단계: 소스 리포지토리에 빌드 사양 파일 추가
<a name="cd-buildspec"></a>

이 자습서에서는 CodeBuild를 사용하여 도커 이미지를 생성하고 Amazon ECR에 이미지를 푸시합니다. `buildspec.yml` 파일을 소스 코드 리포지토리에 추가하여 CodeBuild가 작업을 수행하는 방식을 지정합니다. 아래의 빌드 사양 예제는 다음을 수행합니다.
+ 빌드 전 단계:
  + Amazon ECR에 로그인합니다.
  + 리포지토리 URI를 해당 ECR 이미지로 설정하고 이미지 태그와 소스의 Git 커밋 ID의 첫 7자를 추가합니다.
+ 빌드 단계:
  + 도커 이미지를 빌드하고 `latest` 및 Git 커밋 ID로 이미지에 태그를 지정합니다.
+ 빌드 후 단계:
  + ECR 리포지토리에 두 태그와 함께 이미지를 푸시합니다.
  + Amazon ECS 서비스의 컨테이너 이름과 이미지 및 태그를 포함하는 `imagedefinitions.json` 파일을 빌드 루트에 씁니다. CD 파이프라인의 배포 단계에서는 이 정보를 사용하여 개정된 서비스 작업 정의를 생성한 후 새로운 작업 정의를 사용하도록 서비스를 업데이트합니다. `imagedefinitions.json` 파일은 ECS 작업자에게 필요합니다.

이 샘플 텍스트를 붙여 넣어 `buildspec.yml` 파일을 생성하고 이미지 및 작업 정의의 값을 바꿉니다. 이 텍스트는 예제 계정 ID인 111122223333을 사용합니다.

```
version: 0.2

phases:
  pre_build:
    commands:
      - echo Logging in to Amazon ECR...
      - aws --version
      - aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com
      - REPOSITORY_URI=012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world
      - COMMIT_HASH=$(echo $CODEBUILD_RESOLVED_SOURCE_VERSION | cut -c 1-7)
      - IMAGE_TAG=${COMMIT_HASH:=latest}
  build:
    commands:
      - echo Build started on `date`
      - echo Building the Docker image...
      - docker build -t $REPOSITORY_URI:latest .
      - docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG
  post_build:
    commands:
      - echo Build completed on `date`
      - echo Pushing the Docker images...
      - docker push $REPOSITORY_URI:latest
      - docker push $REPOSITORY_URI:$IMAGE_TAG
      - echo Writing image definitions file...
      - printf '[{"name":"hello-world","imageUri":"%s"}]' $REPOSITORY_URI:$IMAGE_TAG > imagedefinitions.json
artifacts:
    files: imagedefinitions.json
```

이 자습서의 경우 Amazon ECS 서비스에서 사용하는 [사전 조건](#ecs-cd-prereqs)에서 제공된 샘플 태스크 정의에 대해 빌드 사양을 썼습니다. `REPOSITORY_URI` 값은 `image` 리포지토리(이미지 태그 제외)에 해당하고, 파일 끝부분의 `hello-world` 값은 서비스 작업 정의의 컨테이너 이름에 해당합니다.

**`buildspec.yml` 파일을 해당 소스 리포지토리에 추가하려면**

1. 텍스트 편집기를 연 후 위의 빌드 사양을 복사하여 새 파일에 붙여 넣습니다.

1. `REPOSITORY_URI` 값(`012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world`)을 해당 도커 이미지의 Amazon ECR 리포지토리 URI(이미지 태그 제외)로 바꿉니다. `hello-world`를 해당 서비스 작업 정의에서 도커 이미지를 참조하는 컨테이너 이름으로 바꿉니다.

1. `buildspec.yml` 파일을 커밋한 후 소스 리포지토리에 푸시합니다.

   1. 파일을 추가합니다.

      ```
      git add .
      ```

   1. 변경 내용을 커밋합니다.

      ```
      git commit -m "Adding build specification."
      ```

   1. 커밋을 푸시합니다.

      ```
      git push
      ```

## 2단계: CD(Continuous Deployment) 파이프라인 만들기
<a name="pipeline-wizard"></a>

CodePipeline 마법사를 사용하여 파이프라인 단계를 생성하고, 소스 리포지토리를 ECS 서비스에 연결합니다.

**파이프라인을 생성하려면**

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔을 엽니다.

1. [**Welcome**] 페이지에서 [**Create pipeline**]을 선택합니다.

   CodePipeline을 처음으로 사용하는 경우 **Welcome** 페이지 대신 소개 페이지가 나타납니다. **지금 시작**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 파이프라인 이름을 입력합니다. 이 자습서에서 파이프라인 이름은 **hello-world**입니다.

1. **파이프라인 유형**에서는 기본 선택을 **V2**로 유지합니다. 파이프라인 유형은 특성과 가격이 다릅니다. 자세한 내용은 [파이프라인 유형](pipeline-types.md) 단원을 참조하십시오. **다음**을 선택합니다.

1. **3단계: 소스 단계 추가** 페이지의 **소스 공급자**에서 ** AWS CodeCommit**를 선택합니다.

   1. **리포지토리 이름**에서 파이프라인의 소스 위치로 사용할 CodeCommit 리포지토리의 이름을 선택합니다.

   1. **브랜치 이름**에서 사용할 브랜치를 선택한 후 **다음**을 선택합니다.

1. **4단계: 빌드 단계 추가** 페이지에서 **빌드 공급자**에서 **AWS CodeBuild**를 선택한 다음 **프로젝트 생성을** 선택합니다.

   1. **프로젝트 이름**에서 고유한 빌드 프로젝트 이름을 선택합니다. 이 자습서에서 프로젝트 이름은 **hello-world**입니다.

   1. **환경 이미지**에서 **이미지 관리**를 선택합니다.

   1. **운영 체제**에서 **Amazon Linux 2**를 선택합니다.

   1. **런타임**에서 **표준**을 선택합니다.

   1. **이미지**에서 **`aws/codebuild/amazonlinux2-x86_64-standard:3.0`**를 선택합니다.

   1. **이미지 버전** 및 **환경 유형**의 경우 기본값을 사용합니다.

   1. **Docker 이미지를 빌드하거나 빌드에서 승격된 권한을 얻으려는 경우 이 플래그 활성화**를 선택합니다.

   1. **CloudWatch 로그**를 선택 취소합니다. **고급**을 확장해야 할 수도 있습니다.

   1. **Continue to CodePipeline(CodePipeline으로 계속)**을 선택합니다.

   1. **다음**을 선택합니다.
**참고**  
마법사가 빌드 프로젝트를 위한 CodeBuild 서비스 역할(**codebuild-*build-project-name*-service-role**)을 생성합니다. 이 역할 이름은 나중에 Amazon ECR 권한을 역할에 추가할 때 필요하므로 메모해 둡니다.

1. **5단계: 배포 단계 추가** 페이지의 **배포 공급자**에서 **Amazon ECS**를 선택합니다.

   1. **클러스터 이름**에서 해당 서비스가 실행 중인 Amazon ECS 클러스터를 선택합니다. 이 자습서에서는 클러스터가 **default**입니다.

   1. **서비스 이름**에서 업데이트할 서비스를 선택한 후 **다음**을 선택합니다. 이 자습서에서 서비스 이름은 **hello-world**입니다.

1. **6단계: 검토** 페이지에서 파이프라인 구성을 검토하고 **파이프라인 생성**을 선택하여 파이프라인을 생성합니다.
**참고**  
이제 파이프라인이 생성되었으며 다른 파이프라인 단계에서 이 파이프라인이 실행하려고 시도합니다. 하지만 마법사가 만든 기본 CodeBuild 역할이 `buildspec.yml` 파일에 포함된 모든 명령을 실행할 수 있는 권한을 갖고 있지 않으므로 빌드 단계가 실패합니다. 다음 단계에서는 빌드 단계를 위한 권한을 추가합니다.

## 3단계: CodeBuild 역할에 Amazon ECR 권한 추가
<a name="code-build-perms"></a>

CodePipeline 마법사가 CodeBuild 빌드 프로젝트를 위한 IAM 역할(**codebuild-*build-project-name*-service-role**)을 생성했습니다. 이 자습서에서 이름은 **codebuild-hello-world-service-role**입니다. `buildspec.yml` 파일은 Amazon ECR API 작업을 호출하기 때문에 이 역할은 이러한 Amazon ECR 호출을 할 수 있는 권한을 허용하는 정책이 있어야 합니다. 다음 절차에서는 적절한 권한을 역할에 연결합니다.

**CodeBuild 역할에 Amazon ECR 권한을 추가하려면**

1. IAM 콘솔([https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/))을 엽니다.

1. 왼쪽 탐색 창에서 **역할**을 선택합니다.

1. 검색란에 **codebuild-**를 입력하고 CodePipeline 마법사가 생성한 역할을 선택합니다. 이 자습서에서 역할 이름은 **codebuild-hello-world-service-role**입니다.

1. **요약** 페이지에서 **정책 연결**을 선택합니다.

1. **AmazonEC2ContainerRegistryPowerUser** 정책 왼쪽의 상자를 선택하고 **정책 연결**을 선택합니다.

## 4단계: 파이프라인 테스트
<a name="commit-change"></a>

파이프라인에는 end-to-end네이티브 AWS 지속적 배포를 실행하기 위한 모든 것이 있어야 합니다. 이제 소스 리포지토리에 코드 변경을 푸시하여 파이프라인 기능을 테스트해 보겠습니다.

**파이프라인을 테스트하려면**

1. 구성된 소스 리포지토리에 대한 코드를 변경하고 커밋한 후 변경 사항을 푸시합니다.

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔을 엽니다.

1. 목록에서 파이프라인을 선택합니다.

1. 단계를 수행하면서 파이프라인 진행 상황을 관찰합니다. 파이프라인이 완료되고 코드 변경을 통해 생성된 도커 이미지를 Amazon ECS 서비스가 실행해야 합니다.

# 자습서: Amazon ECR 소스 및 ECS-to-CodeDeploy 배포를 사용하여 파이프라인 생성
<a name="tutorials-ecs-ecr-codedeploy"></a>

이 자습서에서는 Docker 이미지를 지원하는 블루/그린 배포를 사용하여 컨테이너 애플리케이션을 배포 AWS CodePipeline 하는 파이프라인을에서 구성합니다. 블루/그린 배포에서는 트래픽을 다시 라우팅하기 전에 이전 버전과 함께 새 버전의 애플리케이션을 시작하고 새 버전을 테스트할 수 있습니다. 또한 배포 프로세스를 모니터링하고 문제가 발생할 경우 신속하게 롤백할 수 있습니다.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

**참고**  
이 자습서는 CodePipeline인의 Amazon ECS에서 CodeDeploy로의 블루/그린 배포 작업을 위한 것입니다. CodePipeline의 Amazon ECS 표준 배포 작업을 사용하는 자습서는 [자습서: CodePipeline을 사용한 Amazon ECS 표준 배포](ecs-cd-pipeline.md) 단원을 참조하세요.

완료된 파이프라인은 이미지 변경 사항을 감지하고 Amazon ECR과 같은 이미지 리포지토리에 저장하고 CodeDeploy를 사용하여 트래픽을 Amazon ECS 클러스터 및 로드 밸런서로 라우팅하고 배포합니다. CodeDeploy는 리스너를 사용하여 AppSpec 파일에 지정된 업데이트된 컨테이너의 포트로 트래픽을 다시 라우팅합니다. 블루/그린 배포에서 로드 밸런서, 프로덕션 리스너, 대상 그룹 및 Amazon ECS 애플리케이션을 사용하는 방법에 대한 자세한 내용은 [자습서: Amazon ECS 서비스 배포](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-ecs-deployment.html)를 참조하세요.

또한 파이프라인도 Amazon ECS 작업 정의가 저장된 CodeCommit과 같은 소스 위치를 사용하도록 구성됩니다. 이 자습서에서는 이러한 각 AWS 리소스를 구성한 다음 각 리소스에 대한 작업이 포함된 단계로 파이프라인을 생성합니다.

지속적 전달 파이프라인은 소스 코드가 변경되거나 새 기본 이미지가 Amazon ECR에 업로드될 때마다 컨테이너 이미지를 자동으로 빌드하고 배포합니다.

이 플로우는 다음 아티팩트를 사용합니다.
+ Amazon ECR 이미지 리포지토리의 URI와 컨테이너 이름을 지정하는 도커 이미지 파일.
+ 도커 이미지 이름, 컨테이너 이름, Amazon ECS 서비스 이름, 로드 밸런서 구성의 목록을 표시하는 Amazon ECS 작업 정의입니다.
+ Amazon ECS 작업 정의 파일의 이름, 업데이트된 애플리케이션 컨테이너의 이름, CodeDeploy가 프로덕션 트래픽을 다시 라우팅하는 컨테이너 포트를 지정하는 CodeDeploy AppSpec 파일입니다. 배포 수명 주기 이벤트 후크 중 실행할 수 있는 Lambda 함수와 네트워크 구성을 선택적으로 지정할 수도 있습니다.

**참고**  
Amazon 이미지 리포지토리에 변경을 커밋하면 파이프라인 ECR 소스 작업이 해당 커밋에 대한 `imageDetail.json` 파일을 생성합니다. `imageDetail.json` 파일에 대한 자세한 내용은 [Amazon ECS 블루/그린 배포 작업을 위한 imageDetail.json 파일](file-reference.md#file-reference-ecs-bluegreen) 단원을 참조하십시오.

파이프라인을 생성 또는 편집하고 배포 단계를 위한 소스 아티팩트를 업데이트 또는 지정할 경우, 사용하려는 최신 이름과 버전의 소스 아티팩트를 지정해야 합니다. 파이프라인을 설정한 후 이미지나 작업 정의를 변경하면 리포지토리에서 소스 결과물을 업데이트한 후 파이프라인에서 배포 단계를 편집해야 할 수 있습니다.

**Topics**
+ [사전 조건](#tutorials-ecs-ecr-codedeploy-prereq)
+ [1단계: 이미지 생성 및 Amazon ECR 리포지토리로 푸시](#tutorials-ecs-ecr-codedeploy-imagerepository)
+ [2단계: 작업 정의 및 AppSpec 소스 파일 생성과 CodeCommit 리포지토리에 푸시](#tutorials-ecs-ecr-codedeploy-taskdefinition)
+ [3단계: Application Load Balancer 및 대상 그룹 만들기](#tutorials-ecs-ecr-codedeploy-loadbal)
+ [4단계: Amazon ECS 클러스터 및 서비스 생성](#tutorials-ecs-ecr-codedeploy-cluster)
+ [5단계: CodeDeploy 애플리케이션 및 배포 그룹 만들기(ECS 컴퓨팅 플랫폼)](#tutorials-ecs-ecr-codedeploy-deployment)
+ [6단계: 파이프라인 생성](#tutorials-ecs-ecr-codedeploy-pipeline)
+ [7단계: 파이프라인 변경 및 배포 확인](#tutorials-ecs-ecr-codedeploy-update)

## 사전 조건
<a name="tutorials-ecs-ecr-codedeploy-prereq"></a>

다음 리소스를 이미 생성했어야 합니다.
+ CodeCommit 리포지토리. 에서 생성한 AWS CodeCommit 리포지토리를 사용할 수 있습니다[자습서: 간단한 파이프라인 생성(CodeCommit 리포지토리)](tutorials-simple-codecommit.md).
+ 이 자습서에 나와 있는 대로 Amazon EC2 Linux 인스턴스를 시작하고 Docker를 설치하여 이미지를 생성합니다. 사용할 이미지가 이미 있으면 이 조건을 무시해도 됩니다.

## 1단계: 이미지 생성 및 Amazon ECR 리포지토리로 푸시
<a name="tutorials-ecs-ecr-codedeploy-imagerepository"></a>

이 섹션에서는 Docker를 사용하여 이미지를 생성한 다음 AWS CLI 를 사용하여 Amazon ECR 리포지토리를 생성하고 이미지를 리포지토리에 푸시합니다.

**참고**  
사용할 이미지가 이미 있으면 단계를 건너뛰어도 됩니다.

**이미지 생성**

1. Docker를 설치한 Linux 인스턴스에 로그인합니다.

   `nginx`용 이미지를 풀다운합니다. 이 명령은 `nginx:latest` 이미지를 제공합니다.

   ```
   docker pull nginx
   ```

1. **docker images**를 실행합니다. 목록에 이미지가 나타나야 합니다.

   ```
   docker images
   ```

**Amazon ECR 리포지토리를 생성하고 이미지를 푸시하려면**

1.  이미지를 저장할 Amazon ECR 리포지토리를 생성합니다. 출력에서 `repositoryUri`를 기록합니다.

   ```
   aws ecr create-repository --repository-name nginx
   ```

   출력:

   ```
   {
       "repository": {
           "registryId": "aws_account_id",
           "repositoryName": "nginx",
           "repositoryArn": "arn:aws:ecr:us-east-1:aws_account_id:repository/nginx",
           "createdAt": 1505337806.0,
           "repositoryUri": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx"
       }
   }
   ```

1. 이전 단계의 `repositoryUri` 값을 사용하여 이미지에 태그를 지정합니다.

   ```
   docker tag nginx:latest aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx:latest
   ```

1. `us-west-2` 리전 및 111122223333 계정 ID의 예와 같이 **aws ecr get-login-password** 명령을 실행합니다.

   ```
   aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com/nginx
   ```

1. 이전 단계의 `repositoryUri`를 사용하여 Amazon ECR로 이미지를 푸시합니다.

   ```
   docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/nginx:latest
   ```

## 2단계: 작업 정의 및 AppSpec 소스 파일 생성과 CodeCommit 리포지토리에 푸시
<a name="tutorials-ecs-ecr-codedeploy-taskdefinition"></a>

이 단원에서는 작업 정의 JSON 파일을 생성하고 Amazon ECS에 등록합니다. 그런 다음 CodeDeploy에 대한 AppSpec 파일을 생성하고, Git 클라이언트를 사용하여 CodeCommit 리포지토리로 파일을 푸시합니다.

**이미지에 대한 작업 정의를 생성하려면**

1. 다음 콘텐츠를 가진 `taskdef.json`이라는 파일을 생성합니다: `image`에 이미지 이름(예: nginx)을 입력합니다. 파이프라인이 실행되면 이 값이 업데이트됩니다.
**참고**  
작업 정의에 지정된 실행 역할에 `AmazonECSTaskExecutionRolePolicy`가 있는지 확인합니다. 자세한 내용을 알아보려면 Amazon ECS 개발자 안내서의 [Amazon ECS 태스크 실행 IAM 역할](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html)을 참조하세요.**

   ```
   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "name": "sample-website",
               "image": "nginx",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "ecs-demo"
   }
   ```

1. `taskdef.json` 파일을 사용하여 작업 정의를 등록합니다.

   ```
   aws ecs register-task-definition --cli-input-json file://taskdef.json
   ```

1. 작업 정의가 등록된 후, 파일을 편집하여 이미지 이름을 제거하고 이미지 필드에 `<IMAGE1_NAME>` 자리 표시자 텍스트를 포함시킵니다.

   ```
   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "name": "sample-website",
               "image": "<IMAGE1_NAME>",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "ecs-demo"
   }
   ```

**AppSpec 파일을 만들려면**
+ AppSpec 파일은 CodeDeploy 배포에 사용됩니다. 선택 필드를 포함하는 파일은 다음 형식을 사용합니다.

  ```
  version: 0.0
  Resources:
    - TargetService:
        Type: AWS::ECS::Service
        Properties:
          TaskDefinition: "task-definition-ARN"
          LoadBalancerInfo:
            ContainerName: "container-name"
            ContainerPort: container-port-number
  # Optional properties
          PlatformVersion: "LATEST"
          NetworkConfiguration:
              AwsvpcConfiguration:
                Subnets: ["subnet-name-1", "subnet-name-2"]
                SecurityGroups: ["security-group"]
                AssignPublicIp: "ENABLED"
  Hooks:
  - BeforeInstall: "BeforeInstallHookFunctionName"
  - AfterInstall: "AfterInstallHookFunctionName"
  - AfterAllowTestTraffic: "AfterAllowTestTrafficHookFunctionName"
  - BeforeAllowTraffic: "BeforeAllowTrafficHookFunctionName"
  - AfterAllowTraffic: "AfterAllowTrafficHookFunctionName"
  ```

  AppSpec 파일에 대한 자세한 내용과 예제는 [CodeDeploy AppSpec 파일 참조](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html)를 참조하세요.

  다음 콘텐츠를 가진 `appspec.yaml`이라는 파일을 생성합니다: `TaskDefinition`에서 `<TASK_DEFINITION>` 자리 표시자 텍스트를 변경하지 마십시오. 파이프라인이 실행되면 이 값이 업데이트됩니다.

  ```
  version: 0.0
  Resources:
    - TargetService:
        Type: AWS::ECS::Service
        Properties:
          TaskDefinition: <TASK_DEFINITION>
          LoadBalancerInfo:
            ContainerName: "sample-website"
            ContainerPort: 80
  ```

**CodeCommit 리포지토리에 파일을 푸시하려면**

1. CodeCommit 리포지토리에 파일을 푸시하거나 업로드합니다. 이러한 파일은 **파이프라인 생성** 마법사가 CodePipeline에서 배포 작업을 위해 생성한 소스 아티팩트입니다. 파일은 로컬 디렉터리에 다음과 같이 나타납니다.

   ```
   /tmp
     |my-demo-repo
       |-- appspec.yaml
       |-- taskdef.json
   ```

1. 파일을 업로드하는 데 사용할 방법을 선택합니다.

   1. 로컬 컴퓨터의 복제된 리포지토리에서 git 명령줄을 사용하려면 다음과 같이 합니다.

      1. 디렉터리를 해당 로컬 리포지토리로 변경합니다.

         ```
         (For Linux, macOS, or Unix) cd /tmp/my-demo-repo
         (For Windows) cd c:\temp\my-demo-repo
         ```

      1. 다음 명령을 실행하여 모든 파일을 한 번에 스테이징합니다.

         ```
         git add -A
         ```

      1. 다음 명령을 실행하여 커밋 메시지와 함께 파일을 커밋합니다.

         ```
         git commit -m "Added task definition files"
         ```

      1. 다음 명령을 실행하여 로컬 리포지토리의 파일을 CodeCommit 리포지토리에 푸시합니다.

         ```
         git push
         ```

   1. CodeCommit 콘솔을 사용하여 파일을 업로드하려면 다음과 같이 합니다.

      1. CodeCommit 콘솔을 열고 **리포지토리** 목록에서 해당 리포지토리를 선택합니다.

      1. **파일 추가**를 선택한 후 **파일 업로드**를 선택합니다.

      1. **파일 선택**을 선택한 후 파일을 찾습니다. 사용자 이름과 이메일 주소를 입력하여 변경 사항을 커밋합니다. **변경 사항 커밋**을 선택합니다.

      1. 업로드하려는 각 파일에 대해 이 단계를 반복합니다.

## 3단계: Application Load Balancer 및 대상 그룹 만들기
<a name="tutorials-ecs-ecr-codedeploy-loadbal"></a>

이 단원에서는 Amazon EC2 Application Load Balancer를 만듭니다. 로드밸런서를 사용하여 생성하는 대상 그룹 값과 서브넷 이름은 나중에 Amazon ECS 서비스를 생성할 때 사용합니다. Application Load Balancer 또는 Network Load Balancer를 생성할 수 있습니다. 로드밸런서는 다른 가용 영역에 두 개의 퍼블릭 서브넷이 있는 VPC를 사용해야 합니다. 이 단계에서는 기본 VPC를 확인하고 로드밸런서를 생성한 후 로드밸런서를 위한 대상 그룹을 두 개 생성합니다. 자세한 내용은 [네트워크 로드밸런서의 대상 그룹 지정](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html)을 참조하십시오.

**기본 VPC와 퍼블릭 서브넷을 확인하려면**

1. 에 로그인 AWS Management Console 하고 [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) Amazon VPC 콘솔을 엽니다.

1. 사용할 기본 VPC를 확인합니다. 탐색 창에서 **Your VPCs**를 선택합니다. **기본 VPC** 열에서 **예**로 표시된 VPC를 확인합니다. 이것이 기본 VPC입니다. 이 VPC에는 선택할 기본 서브넷이 포함됩니다.

1. **서브넷**을 선택합니다. **기본 서브넷** 열에 **예**로 표시되는 서브넷을 두 개 선택합니다.
**참고**  
서브넷 ID를 기록해 둡니다. 이 자습서 뒷부분에서 이 정보가 필요합니다.

1. 서브넷을 선택한 후 **설명** 탭을 선택합니다. 사용할 서브넷이 다른 가용 영역에 있는지 확인합니다.

1. 서브넷을 선택한 후 **라우팅 테이블** 탭을 선택합니다. 사용할 각 서브넷이 퍼블릭 서브넷인지 확인하려면, 라우팅 테이블에 게이트웨이 행이 포함되어 있는지 확인합니다.

**Amazon EC2 Application Load Balancer를 생성하려면**

1. 에 로그인 AWS Management Console 하고 [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) Amazon EC2 콘솔을 엽니다.

1. 탐색 창에서 **로드 밸런서**를 클릭합니다.

1. **로드 밸런서 생성**을 선택합니다.

1. **Application Load Balancer**를 선택하고 **생성**을 선택합니다.

1. **이름**에 로드밸런서의 이름을 입력합니다.

1. **체계**에서 **인터넷 연결**을 선택합니다.

1. **IP 주소 유형**에서 **ipv4**를 선택합니다.

1. 로드밸런서를 위한 리스너 두 개를 구성하려면 다음과 같이 합니다.

   1. **로드밸런서 프로토콜**에서 **HTTP**를 선택합니다. **로드 밸런서 포트**에 **80**을 입력합니다.

   1. **리스너 추가**를 선택합니다.

   1. 두 번째 리스너의 **로드밸런서 프로토콜**에서 **HTTP**를 선택합니다. **로드 밸런서 포트**에 **8080**을 입력합니다.

1. **가용 영역**의 **VPC**에서 기본 VPC를 선택합니다. 그런 다음 사용할 기본 서브넷 두 개를 선택합니다.

1. **다음: 보안 설정 구성**을 선택합니다.

1. **다음: 보안 그룹 구성(Next: Configure Security Groups)**을 선택합니다.

1. **기존 보안 그룹 선택**을 선택하고 보안 그룹 ID를 기록해 둡니다.

1. **다음: 라우팅 구성(Next: Configure Routing)**을 선택합니다.

1. **대상 그룹**에서 **새 대상 그룹**을 선택하고 첫 번째 대상 그룹을 구성합니다.

   1. **이름**에 대상 그룹 이름(예: **target-group-1**)을 입력합니다.

   1. **대상 형식**에서 **IP**을 선택합니다.

   1. **프로토콜**에서 **HTTP**를 선택합니다. **포트**에 **80**을 입력합니다.

   1. **다음: 대상 등록(Next: Register Targets)**을 선택합니다.

1. **다음: 검토**를 선택한 후 **역할 생성**을 선택합니다.

**로드밸런서에 대한 두 번째 대상 그룹을 생성하려면**

1. 로드밸런서가 프로비저닝된 후 Amazon EC2 콘솔을 엽니다. 탐색 창에서 **대상 그룹**을 선택합니다.

1. **대상 그룹 생성**을 선택합니다.

1. **이름**에 대상 그룹 이름(예: **target-group-2**)을 입력합니다.

1. **대상 형식**에서 **IP**을 선택합니다.

1. **프로토콜**에서 **HTTP**를 선택합니다. **포트**에 **8080**을 입력합니다.

1. **VPC**에서 기본 VPC를 선택합니다.

1. **생성(Create)**을 선택합니다.
**참고**  
배포를 실행하려면 로드밸런서에 대해 두 개의 대상 그룹을 생성해야 합니다. 첫 번째 대상 그룹의 ARN만 기록해 두면 됩니다. 이 ARN은 다음 단계에서 `create-service` JSON 파일에 사용됩니다.

**두 번째 대상 그룹을 포함하도록 로드밸런서를 업데이트하려면**

1. Amazon EC2 콘솔을 엽니다. 탐색 창에서 **로드 밸런서**를 클릭합니다.

1. 로드 밸런서를 선택한 후 **리스너** 탭을 선택합니다. 포트 번호가 8080인 리스너를 선택한 후 **편집**을 선택합니다.

1. **전달 대상** 옆의 연필 아이콘을 선택합니다. 두 번째 대상 그룹을 선택한 후 확인 표시를 선택합니다. **업데이트**를 선택하여 업데이트를 저장합니다.

## 4단계: Amazon ECS 클러스터 및 서비스 생성
<a name="tutorials-ecs-ecr-codedeploy-cluster"></a>

이 단원에서는 배포 중 CodeDeploy가 EC2 인스턴스가 아닌 Amazon ECS 클러스터로 트래픽을 라우팅할 Amazon ECS 클러스터와 서비스를 생성합니다. Amazon ECS 서비스를 생성하려면 로드 밸런서를 사용하여 생성한 대상 그룹 값과 서브넷 이름 및 보안 그룹을 사용하여 서비스를 생성해야 합니다.

**참고**  
이 단계를 사용하여 Amazon ECS 클러스터를 생성할 때 Fargate 컨테이너를 프로비저닝 AWS 하는 **네트워킹 전용** 클러스터 템플릿을 사용합니다. AWS Fargate는 컨테이너 인스턴스 인프라를 관리하는 기술입니다. Amazon ECS 클러스터에 대한 Amazon EC2 인스턴스를 선택하거나 수동으로 생성할 필요가 없습니다.

**Amazon ECS 클러스터를 생성하려면**

1. [https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/)에서 Amazon ECS 클래식 콘솔을 엽니다.

1. 탐색 창에서 **클러스터**를 선택합니다.

1. **클러스터 생성**을 선택합니다.

1.  AWS Fargate 기반의 **네트워킹 전용** 클러스터 템플릿을 선택한 후 **다음 단계**를 선택합니다.

1. **Configure cluster(클러스터 구성)** 페이지에 클러스터 이름을 입력합니다. 리소스에 대한 선택적 태그를 추가할 수 있습니다. **생성(Create)**을 선택합니다.

**Amazon ECS 서비스를 생성하려면**

 AWS CLI 를 사용하여 Amazon ECS에서 서비스를 생성합니다.

1. JSON 파일을 생성하고 이름을 `create-service.json`으로 지정합니다. JSON 파일에 다음을 붙여 넣습니다.

   `taskDefinition` 필드의 경우 Amazon ECS에 작업 정의를 등록할 때 패밀리를 정의합니다. 패밀리는 개정 번호를 사용하여 지정된 작업 정의의 여러 버전에 대한 이름과 비슷합니다. 이 예에서는 파일에 있는 패밀리 및 개정 번호에 "`ecs-demo:1`"을 사용합니다. [3단계: Application Load Balancer 및 대상 그룹 만들기](#tutorials-ecs-ecr-codedeploy-loadbal) 단원에서 로드 밸런서를 사용하여 생성한 대상 그룹 값과 서브넷 이름 및 보안 그룹을 사용합니다.
**참고**  
이 파일에 대상 그룹 ARN을 포함시켜야 합니다. Amazon EC2 콘솔을 열고 탐색 창의 **로드 밸런싱**에서 **대상 그룹**을 선택합니다. 첫 번째 대상 그룹을 선택합니다. **설명** 탭에서 ARN을 복사합니다.

   ```
   {
       "taskDefinition": "family:revision-number",
       "cluster": "my-cluster",
       "loadBalancers": [
           {
               "targetGroupArn": "target-group-arn",
               "containerName": "sample-website",
               "containerPort": 80
           }
       ],
       "desiredCount": 1,
       "launchType": "FARGATE",
       "schedulingStrategy": "REPLICA",
       "deploymentController": {
           "type": "CODE_DEPLOY"
       },
       "networkConfiguration": {
           "awsvpcConfiguration": {
               "subnets": [
                   "subnet-1",
                   "subnet-2"
               ],
               "securityGroups": [
                   "security-group"
               ],
               "assignPublicIp": "ENABLED"
           }
       }
   }
   ```

1. JSON 파일을 지정하여 **create-service** 명령을 실행합니다.
**중요**  
파일 이름 앞에 `file://`를 포함해야 합니다. 이 명령에 필수적입니다.

   이 예제에서는 `my-service`라는 서비스를 생성합니다.
**참고**  
이 예제 명령은 my-service라는 서비스를 생성합니다. 이 이름의 서비스가 이미 있는 경우, 명령은 오류를 반환합니다.

   ```
   aws ecs create-service --service-name my-service --cli-input-json file://create-service.json
   ```

   출력에 서비스의 설명 필드가 반환됩니다.

1. **describe-services** 명령을 실행하여 서비스가 생성되었는지 확인합니다.

   ```
   aws ecs describe-services --cluster cluster-name --services service-name
   ```

## 5단계: CodeDeploy 애플리케이션 및 배포 그룹 만들기(ECS 컴퓨팅 플랫폼)
<a name="tutorials-ecs-ecr-codedeploy-deployment"></a>

Amazon ECS 컴퓨팅 플랫폼에 대한 CodeDeploy 애플리케이션 및 배포 그룹을 만드는 경우 애플리케이션은 배포 중에 올바른 배포 그룹, 대상 그룹, 리스너 및 트래픽 라우팅 동작을 참조하는 데 사용됩니다.

**CodeDeploy 애플리케이션을 만들려면**

1. CodeDeploy 콘솔을 열고 **애플리케이션 생성**을 선택합니다.

1. **애플리케이션 이름**에 사용하려는 이름을 입력합니다.

1. **컴퓨팅 플랫폼**에서 **Amazon ECS**를 선택합니다.

1. **애플리케이션 생성**을 선택합니다.

**CodeDeploy 배포 그룹을 생성하려면**

1. 애플리케이션 페이지의 **배포 그룹** 탭에서 **배포 그룹 생성**을 선택합니다.

1. **Deployment group name(배포 그룹 이름)**에 배포 그룹을 설명하는 이름을 입력합니다.

1. **서비스 역할**에서 Amazon ECS에 액세스할 수 있는 권한을 CodeDeploy에 부여하는 서비스 역할을 선택합니다. 새 서비스 역할을 생성하려면 다음 단계를 수행합니다.

   1. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)에서 IAM 콘솔을 엽니다.

   1. 콘솔 대시보드에서 **역할**을 선택합니다.

   1. **역할 생성**을 선택합니다.

   1. **신뢰할 수 있는 유형의 엔터티 선택**에서 **AWS 서비스**를 선택합니다. **Choose a use case(사용 사례 선택)**에서 **CodeDeploy**를 선택합니다. **Select your use case(사용 사례 선택)**에서 **CodeDeploy - ECS**를 선택합니다. **다음: 권한**을 선택합니다. `AWSCodeDeployRoleForECS` 관리형 정책이 역할에 연결됩니다.

   1. **Next: Tags(다음: 태그)**를 선택한 후 **Next: Review(다음: 검토)**를 선택합니다.

   1. 역할 이름(예: **CodeDeployECSRole**)을 입력한 후 **Create role(역할 생성)**을 선택합니다.

1. **환경 구성**에서 Amazon ECS 클러스터 이름과 서비스 이름을 선택합니다.

1. **로드 밸런서**에서 Amazon ECS 서비스에 트래픽을 공급하는 로드밸런서의 이름을 선택합니다.

1. **프로덕션 리스너 포트**에서 해당 Amazon ECS 서비스에 서비스 프로덕션 트래픽을 공급하는 리스너의 프로토콜과 포트를 선택합니다. **Test listener port(테스트 리스너 포트)**에서 테스트 리스너를 위한 포트와 프로토콜을 선택합니다.

1. **대상 그룹 1 이름**과 **대상 그룹 2 이름**에서 배포 중 트래픽을 라우팅하는 데 사용되는 대상 그룹을 선택합니다. 해당 로드밸런서용으로 생성한 대상 그룹인지 확인합니다.

1. **즉시 트래픽 다시 라우팅**을 선택하여 배포 성공 후 얼마 후에 업데이트된 Amazon ECS 작업으로 트래픽을 다시 라우팅할지를 지정합니다.

1. [**Create deployment group**]을 선택합니다.

## 6단계: 파이프라인 생성
<a name="tutorials-ecs-ecr-codedeploy-pipeline"></a>

이 단원에서는 다음 작업을 통해 파이프라인을 생성합니다.
+ 소스 아티팩트가 작업 정의 및 AppSpec 파일인 경우 CodeCommit 작업.
+ 소스 아티팩트가 이미지 파일인 경우 Amazon ECR 소스 작업을 포함하는 소스 단계.
+ CodeDeploy 애플리케이션 및 배포 그룹을 통한 배포가 실행될 경우 Amazon ECS 배포 작업을 포함하는 배포 단계.

**마법사를 사용하여 2단계 파이프라인을 생성하려면**

1. 에 로그인 AWS Management Console 하고 [http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) CodePipeline 콘솔을 엽니다.

1. [**Welcome**] 페이지, [**Getting started**] 페이지 또는 [**Pipelines**] 페이지에서 **Create pipeline(파이프라인 생성)**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 **MyImagePipeline**을 입력합니다.

1. CodePipeline은 특성과 가격이 다른 V1 및 V2 유형 파이프라인을 제공합니다. V2 유형은 콘솔에서 선택할 수 있는 유일한 유형입니다. 자세한 내용은 [파이프라인 유형](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)을 참조하세요. CodePipeline에 대한 요금 정보는 [요금](https://aws.amazon.com/codepipeline/pricing/)을 참조하세요.

1. **서비스 역할**에서 **새 서비스 역할**을 선택하여CodePipeline이 IAM에 서비스 역할을 생성하도록 허용합니다.

1. [**Advanced settings**]의 설정은 기본값 그대로 두고, [**Next**]를 선택합니다.

1. **3단계: 소스 스테이지 추가**의 **소스 공급자**에서 **AWS CodeCommit**을 선택합니다. **리포지토리 이름**에서 [1단계: CodeCommit 리포지토리 생성](tutorials-simple-codecommit.md#codecommit-create-repository)에서 생성한 CodeCommit 리포지토리의 이름을 선택합니다. [**Branch name**]에서 가장 마지막 코드 업데이트가 포함된 브랜치의 이름을 선택합니다.

   **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가**에서 **빌드 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다. **다음**을 선택합니다.

1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **6단계: 배포 단계 추가**에서:

   1. **배포 공급자**에서 **Amazon ECS(블루/그린)**를 선택합니다. **애플리케이션 이름**에 애플리케이션 이름을 입력하거나 목록에서 선택합니다(`codedeployapp`). **배포 그룹**에 배포 그룹 이름을 입력하거나 목록에서 선택합니다(예: `codedeploydeplgroup`).

       
**참고**  
"Deploy"라는 이름은 파이프라인의 첫 단계에 "Source"라는 이름이 지정되는 것처럼 **4단계: 배포** 단계에서 생성한 단계에 기본적으로 지정되는 이름입니다.

   1. **Amazon ECS 작업 정의**에서 **SourceArtifact**를 선택합니다. 필드에 **taskdef.json**을 입력합니다.

   1. **AWS CodeDeploy AppSpec 파일**에서 **SourceArtifact**를 선택합니다. 필드에 **appspec.yaml**을 입력합니다.
**참고**  
이때 **작업 정의 이미지를 동적으로 업데이트**에는 아무 정보도 입력하지 마십시오.

   1. **다음**을 선택합니다.

1. **7단계: 검토**에서 정보를 검토한 다음 **파이프라인 생성을** 선택합니다.

**파이프라인에 Amazon ECR 소스 작업을 추가하려면**

파이프라인을 보고 파이프라인에 Amazon ECR 소스 작업을 추가합니다.

1. 파이프라인을 선택합니다. 왼쪽 위에서 **편집**을 선택합니다.

1. 소스 스테이지에서 **단계 편집**을 선택합니다.

1. CodeCommit 소스 작업 옆의 **\$1 작업 추가**를 선택하여 병렬 작업을 추가합니다.

1. **작업 이름**에 이름을 입력합니다(예: **Image**).

1. **작업 공급자**에서 **Amazon ECR**을 선택합니다.  
![\[\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/ECR-source-action.png)

1. **리포지토리 이름**에서 Amazon ECR 리포지토리의 이름을 선택합니다.

1. 이미지 이름과 버전이 최신과 다른 경우 **이미지 태그**에서 지정합니다.

1. **출력 아티팩트**에서 출력 아티팩트 기본값(예: `MyImage`)을 선택합니다. 이 아티팩트는 다음 단계에서 사용하려는 이미지 이름과 리포지토리 URI를 포함합니다.

1. 작업 화면에서 **저장**을 선택합니다. 단계 화면에서 **완료**를 선택합니다. 파이프라인에서 **저장**을 선택합니다. Amazon ECR 소스 작업에 대해 생성될 Amazon CloudWatch Events 규칙이 메시지에 표시됩니다.

**소스 아티팩트를 배포 작업에 연결하려면**

1. 배포 단계에서 **편집**을 선택하고 아이콘을 선택하여 **Amazon ECS(블루/그린)** 작업을 편집합니다.

1. 창 하단으로 스크롤합니다. **입력 아티팩트**에서 **추가**를 선택합니다. 새로운 Amazon ECR 리포지토리에서 아티팩트 결과물을 추가합니다(예: `MyImage`).

1. **작업 정의**에서 **SourceArtifact**를 선택한 후 **taskdef.json**이 입력되어 있는지 확인합니다.

1. **AWS CodeDeploy AppSpec 파일**에서 **SourceArtifact**를 선택한 후 **appspec.yaml**이 입력되어 있는지 확인합니다.

1. **Dynamically update task definition image(작업 정의 이미지를 동적으로 업데이트)​**의 **Input Artifact with Image URI(이미지 URI가 있는 입력 아티팩트)**에서 **MyImage**를 선택한 후 `taskdef.json` 파일에 사용되는 자리 표시자 텍스트인 ** IMAGE1\$1NAME**을 입력합니다. **저장**을 선택합니다.

1.  AWS CodePipeline 창에서 **파이프라인 변경 사항 저장**을 선택한 다음 **변경 사항 저장**을 선택합니다. 업데이트된 파이프라인을 확인합니다.

   이 예제 파이프라인이 생성되면 콘솔 항목에 대한 작업 구성이 파이프라인 구조에 다음과 같이 표시됩니다.

   ```
   "configuration": {
     "AppSpecTemplateArtifact": "SourceArtifact",
     "AppSpecTemplatePath": "appspec.yaml",
     "TaskDefinitionTemplateArtifact": "SourceArtifact",
     "TaskDefinitionTemplatePath": "taskdef.json",
     "ApplicationName": "codedeployapp",
     "DeploymentGroupName": "codedeploydeplgroup",
     "Image1ArtifactName": "MyImage",
     "Image1ContainerName": "IMAGE1_NAME"
   },
   ```

1. 변경 사항을 제출하고 파이프라인 빌드를 시작하려면 **변경 사항 배포**를 선택한 다음 **릴리스**를 선택하세요.

1. CodeDeploy에서 볼 배포 작업을 선택하고 트래픽 이동의 진행 상황을 확인하세요.
**참고**  
선택적인 대기 시간을 보여주는 배포 단계를 볼 수 있습니다. 기본적으로 CodeDeploy는 원래 작업 세트를 종료하기 전에 성공적인 배포 후 1시간을 대기합니다. 이 시간을 사용하여 작업을 롤백하거나 종료할 수 있지만 작업 세트가 종료되면 배포가 완료됩니다.

## 7단계: 파이프라인 변경 및 배포 확인
<a name="tutorials-ecs-ecr-codedeploy-update"></a>

이미지를 변경한 후 변경 사항을 Amazon ECR 리포지토리에 푸시합니다. 이렇게 하면 파이프라인이 실행됩니다. 이미지 소스 변경이 배포되었는지 확인합니다.

# 자습서: Amazon Alexa Skill을 배포하는 파이프라인 생성
<a name="tutorials-alexa-skills-kit"></a>

이 자습서에서는 배포 단계에서 배포 공급자로 Alexa Skills Kit를 사용하여 Alexa 스킬을 지속적으로 제공하는 파이프라인을 구성합니다. 완성된 파이프 라인은 소스 리포지토리의 소스 파일을 변경할 때 스킬에 대한 변경 사항을 감지합니다. 파이프라인은 Alexa Skills Kit를 사용하여 Alexa 스킬 개발 단계에 배포합니다.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

**참고**  
이 기능은 아시아 태평양(홍콩) 또는 유럽(밀라노) 리전에서 사용할 수 없습니다. 해당 리전에서 사용 가능한 다른 배포 작업을 사용하려면 [배포 작업 통합](integrations-action-type.md#integrations-deploy)을 참조하세요.

사용자 지정 스킬을 Lambda 함수로 생성하려면 사용자 [지정 스킬을 AWS Lambda 함수로 호스팅을](https://developer.amazon.com/docs/custom-skills/host-a-custom-skill-as-an-aws-lambda-function.html) 참조하세요. Lambda 소스 파일과 CodeBuild 프로젝트를 사용하여 스킬 변경 사항을 Lambda에 배포하는 파이프라인을 생성할 수도 있습니다.

## 사전 조건
<a name="tutorials-alexa-skills-kit-prereq"></a>

다음 항목이 있어야 합니다.
+ CodeCommit 리포지토리. 에서 생성한 AWS CodeCommit 리포지토리를 사용할 수 있습니다[자습서: 간단한 파이프라인 생성(CodeCommit 리포지토리)](tutorials-simple-codecommit.md).
+ Amazon 개발자 계정. 이 계정은 Alexa Skill을 소유합니다. [Alexa Skills Kit](https://developer.amazon.com/alexa-skills-kit)에서 무료로 계정을 만들 수 있습니다.
+ Alexa Skill. [Get Custom Skill Sample Code](https://developer.amazon.com/docs/custom-skills/use-the-alexa-skills-kit-samples.html) 자습서를 사용하여 샘플 스킬을 만들 수 있습니다.
+ ASK CLI를 설치하고 AWS 자격 증명으로 `ask init`를 사용하여 구성합니다. 자세한 내용은 [Install and initialize ASK CLI](https://developer.amazon.com/docs/smapi/quick-start-alexa-skills-kit-command-line-interface.html#install-initialize) 단원을 참조하십시오.

## 1단계: Alexa 개발자 서비스 LWA 보안 프로필 생성
<a name="tutorials-alexa-skills-kit-profile"></a>

이 단원에서는 Login With Amazon(LWA)에 사용할 보안 프로필을 만듭니다. 이미 프로필이 있다면 이 단계를 생략할 수 있습니다.
+ 보안 프로필을 만들려면 [generate-lwa-tokens](https://developer.amazon.com/docs/smapi/ask-cli-command-reference.html#generate-lwa-tokens)의 단계를 사용합니다.
+ 프로필을 만든 후 **Client ID(클라이언트 ID)** 및 **Client Secret(클라이언트 암호)**을 메모합니다.
+ 지침에 제공된 대로 **Allowed Return URLs(허용된 반환 URL)**를 입력했는지 확인합니다. URL을 통해 ASK CLI 명령은 새로 고침 토큰 요청을 리디렉션할 수 있습니다.

## 2단계: Alexa Skill 소스 파일 생성 및 CodeCommit 리포지토리에 푸시
<a name="tutorials-alexa-skills-kit-push"></a>

이 단원에서는 파이프라인이 소스 단계에 대해 사용하는 리포지토리에 Alexa Skill 소스 파일을 생성하고 푸시합니다. Amazon 개발자 콘솔에서 생성한 스킬의 경우 다음 항목을 생성하고 푸시합니다.
+ `skill.json` 파일.
+ `interactionModel/custom` 폴더.
**참고**  
이 디렉터리 구조는 [기술 패키지 형식](https://developer.amazon.com/docs/smapi/skill-package-api-reference.html#skill-package-format)에 개략적으로 설명된 Alexa Skills Kit 기술 패키지 형식 요구 사항을 준수합니다. 해당 디렉터리 구조에서 올바른 기술 패키지 형식을 사용하지 않는 경우 변경 사항은 Alexa Skills Kit 콘솔에 성공적으로 배포되지 않습니다.

**스킬에 대한 소스 파일을 생성하려면**

1. Alexa Skills Kit 개발자 콘솔에서 스킬 ID를 검색합니다. 다음 명령을 사용합니다.

   ```
   ask api list-skills
   ```

   스킬별로 이름을 지정한 다음 `skillId` 필드에 연결된 ID를 복사합니다.

1. 스킬 세부 정보가 포함되어 있는 `skill.json` 파일을 생성합니다. 다음 명령을 사용합니다.

   ```
   ask api get-skill -s skill-ID > skill.json
   ```

1. (선택 사항) `interactionModel/custom` 폴더를 만듭니다.

   이 명령을 사용하여 폴더 내에 상호 작용 모델 파일을 생성합니다. 언어의 경우 이 자습서에서는 파일 이름의 언어로 en-US를 사용합니다.

   ```
   ask api get-model --skill-id skill-ID --locale locale >
       ./interactionModel/custom/locale.json
   ```

**CodeCommit 리포지토리에 파일을 푸시하려면**

1. CodeCommit 리포지토리에 파일을 푸시하거나 업로드합니다. 이러한 파일은 **파이프라인 생성** 마법사가 AWS CodePipeline에서 배포 작업을 위해 생성한 소스 아티팩트입니다. 파일은 로컬 디렉터리에 다음과 같이 나타납니다.

   ```
   skill.json
   /interactionModel
     /custom
       |en-US.json
   ```

1. 파일을 업로드하는 데 사용할 방법을 선택합니다.

   1. 로컬 컴퓨터의 복제된 리포지토리에서 Git 명령줄을 사용하려면 다음과 같이 합니다.

      1. 다음 명령을 실행하여 모든 파일을 한 번에 스테이징합니다.

         ```
         git add -A
         ```

      1. 다음 명령을 실행하여 커밋 메시지와 함께 파일을 커밋합니다.

         ```
         git commit -m "Added Alexa skill files"
         ```

      1. 다음 명령을 실행하여 로컬 리포지토리의 파일을 CodeCommit 리포지토리에 푸시합니다.

         ```
         git push
         ```

   1. CodeCommit 콘솔을 사용하여 파일을 업로드하려면 다음과 같이 합니다.

      1. CodeCommit 콘솔을 열고 **리포지토리** 목록에서 해당 리포지토리를 선택합니다.

      1. **파일 추가**를 선택한 후 **파일 업로드**를 선택합니다.

      1. **파일 선택**을 선택한 후 파일을 찾습니다. 사용자 이름과 이메일 주소를 입력하여 변경 사항을 커밋합니다. **변경 사항 커밋**을 선택합니다.

      1. 업로드하려는 각 파일에 대해 이 단계를 반복합니다.

## 3단계: ASK CLI 명령을 사용하여 새로 고침 토큰 생성
<a name="tutorials-alexa-skills-kit-token"></a>

CodePipeline은 Amazon 개발자 계정의 클라이언트 ID와 암호를 기반으로 새로 고침 토큰을 사용하여 사용자를 대신하여 수행하는 작업을 인증합니다. 이 단원에서는 ASK CLI를 사용하여 토큰을 만듭니다. **파이프라인 생성** 마법사를 사용할 때 이 자격 증명을 사용합니다.

**Amazon 개발자 계정 자격 증명으로 새로 고침 토큰을 생성하려면**

1. 다음 명령을 사용합니다.

   ```
   ask util generate-lwa-tokens
   ```

1. 메시지가 표시되면 다음 예와 같이 클라이언트 ID와 암호를 입력합니다.

   ```
   ? Please type in the client ID: 
   amzn1.application-client.example112233445566
   ? Please type in the client secret:
   example112233445566
   ```

1. 로그인 브라우저 페이지가 표시됩니다. Amazon 개발자 계정 자격 증명으로 로그인합니다.

1. 명령줄 화면으로 돌아갑니다. 액세스 토큰 및 새로 고침 토큰이 출력에 생성됩니다. 출력에 반환된 새로 고침 토큰을 복사합니다.

## 4단계: 파이프라인 생성
<a name="tutorials-alexa-skills-kit-pipeline"></a>

이 단원에서는 다음 작업을 통해 파이프라인을 생성합니다.
+ 소스 아티팩트가 사용자의 스킬을 지원하는 Alexa Skill 파일인 CodeCommit 작업이 있는 소스 단계.
+ Alexa Skill Kit 배포 작업이 적용된 배포 단계.

**마법사를 사용하여 파이프라인을 생성하려면**

1. 에 로그인 AWS Management Console 하고 [http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) CodePipeline 콘솔을 엽니다.

1. 프로젝트와 리소스를 생성할 AWS 리전을 선택합니다. Alexa skill 실행 시간은 다음 리전에서만 사용 가능합니다.
   + 아시아 태평양(도쿄)
   + 유럽(아일랜드)
   + 미국 동부(버지니아 북부)
   + 미국 서부(오레곤)

1. [**Welcome**] 페이지, [**Getting started**] 페이지 또는 [**Pipelines**] 페이지에서 **Create pipeline(파이프라인 생성)**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 **MyAlexaPipeline**을 입력합니다.

1. CodePipeline은 특성과 가격이 다른 V1 및 V2 유형 파이프라인을 제공합니다. V2 유형은 콘솔에서 선택할 수 있는 유일한 유형입니다. 자세한 내용은 [파이프라인 유형](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)을 참조하세요. CodePipeline에 대한 요금 정보는 [요금](https://aws.amazon.com/codepipeline/pricing/)을 참조하세요.

1. **서비스 역할**에서 **새 서비스 역할**을 선택하여CodePipeline이 IAM에 서비스 역할을 생성하도록 허용합니다.

1. [**Advanced settings**]의 설정은 기본값 그대로 두고, [**Next**]를 선택합니다.

1. **3단계: 소스 스테이지 추가**의 **소스 공급자**에서 **AWS CodeCommit**을 선택합니다. **리포지토리 이름**에서 [1단계: CodeCommit 리포지토리 생성](tutorials-simple-codecommit.md#codecommit-create-repository)에서 생성한 CodeCommit 리포지토리의 이름을 선택합니다. [**Branch name**]에서 가장 마지막 코드 업데이트가 포함된 브랜치의 이름을 선택합니다.

   리포지토리 이름과 브랜치를 선택하면 이 파이프라인에 대해 생성될 Amazon CloudWatch Events 규칙을 보여 주는 메시지가 표시됩니다.

   **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가**에서 **빌드 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **6단계: 배포 단계 추가**에서:

   1. **배포 공급자**에서 **Alexa Skills Kit**를 선택합니다.

   1. **Alexa skill ID**에 Alexa Skills Kit 개발자 콘솔의 스킬에 할당된 스킬 ID를 입력합니다.

   1. **Client ID(클라이언트 ID)**에 등록한 애플리케이션의 ID를 입력합니다.

   1. **Client secret(클라이언트 암호)**에 등록할 때 선택한 암호를 입력합니다.

   1. **Refresh token(새로 고침 토큰)**에 3단계에서 생성한 토큰을 입력합니다.  
![\[Alexa Skills Kit 작업에 대한 6단계: 배포 페이지\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/alexa-deploy.png)

   1. **다음**을 선택합니다.

1. **7단계: 검토**에서 정보를 검토한 다음 **파이프라인 생성을** 선택합니다.

## 5단계: 모든 소스 파일을 변경하고 배포 확인
<a name="tutorials-alexa-skills-kit-update"></a>

스킬을 변경한 후 변경 사항을 리포지토리에 푸시합니다. 이렇게 하면 파이프라인이 실행됩니다. [Alexa Skills Kit 개발자 콘솔](https://developer.amazon.com/alexa/console/ask)에서 스킬이 업데이트되었는지 확인합니다.

# 자습서: Amazon S3를 배포 공급자로 사용하는 파이프라인 생성
<a name="tutorials-s3deploy"></a>

이 자습서에서는 배포 단계에서 배포 작업 공급자로 Amazon S3를 사용하여 파일을 지속적으로 제공하는 파이프라인을 구성합니다. 완성된 파이프 라인은 소스 리포지토리의 소스 파일을 변경할 때 변경 사항을 감지합니다. 그런 다음 파이프라인은 Amazon S3를 사용하여 파일을 버킷에 배포합니다. 소스 위치에서 웹 사이트 파일을 수정 또는 추가할 때마다 배포 작업에서 최신 파일을 사용하여 웹 사이트가 작성됩니다.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

**참고**  
소스 리포지토리에서 파일을 삭제하더라도 S3 배포 작업은 삭제된 파일에 해당하는 S3 객체를 삭제하지 않습니다.

이 자습서에서는 두 가지 옵션을 제공합니다.
+ 정적 웹 사이트를 S3 퍼블릭 버킷에 배포하는 파이프라인을 생성합니다. 이 예제에서는 AWS CodeCommit 소스 작업과 Amazon S3 배포 작업이 있는 파이프라인을 생성합니다. [옵션 1: Amazon S3에 정적 웹 사이트 배포](#tutorials-s3deploy-acc)을(를) 참조하세요.
+ 샘플 TypeScript 코드를 JavaScript로 컴파일하는 파이프라인을 생성하고 CodeBuild 출력 아티팩트를 아카이브용 S3 버킷에 배포합니다. 이 예제에서는 Amazon S3 소스 작업, CodeBuild 빌드 작업 및 Amazon S3 배포 작업을 통해 파이프라인을 생성합니다. [옵션 2: S3 소스 버킷에서 Amazon S3에 빌드된 아카이브 파일 배포](#tutorials-s3deploy-s3source)을(를) 참조하세요.

**중요**  
이 절차에서 파이프라인에 추가하는 많은 작업에는 파이프라인을 생성하기 전에 생성해야 하는 AWS 리소스가 포함됩니다. 소스 작업에 대한 AWS 리소스는 항상 파이프라인을 생성하는 리전과 동일한 AWS 리전에서 생성해야 합니다. 예를 들어, 미국 동부(오하이오) 리전에서 파이프라인을 생성하는 경우, CodeCommit 리포지토리도 미국 동부(오하이오) 리전에 있어야 합니다.  
파이프라인을 생성할 때 교차 리전 작업을 추가할 수 있습니다. 교차 리전 작업에 대한 AWS 리소스는 작업을 실행하려는 리전과 동일한 AWS 리전에 있어야 합니다. 자세한 내용은 [CodePipeline에 교차 리전 작업 추가](actions-create-cross-region.md) 단원을 참조하십시오.

## 옵션 1: Amazon S3에 정적 웹 사이트 배포
<a name="tutorials-s3deploy-acc"></a>

이 예제에서는 샘플 정적 웹 사이트 템플릿 파일을 다운로드하고, AWS CodeCommit 리포지토리에 파일을 업로드하고, 버킷을 생성하고, 호스팅을 위해 구성합니다. 그런 다음 AWS CodePipeline 콘솔을 사용하여 파이프라인을 생성하고 Amazon S3 배포 구성을 지정합니다.

### 사전 조건
<a name="tutorials-s3deploy-acc-prereq"></a>

다음 항목이 있어야 합니다.
+ CodeCommit 리포지토리. 에서 생성한 AWS CodeCommit 리포지토리를 사용할 수 있습니다[자습서: 간단한 파이프라인 생성(CodeCommit 리포지토리)](tutorials-simple-codecommit.md).
+ 정적 웹 사이트의 소스 파일. 이 링크를 사용하여 [샘플 정적 웹 사이트](samples/sample-website.zip)를 다운로드합니다. sample-website.zip 다운로드는 다음 파일을 생성합니다.
  + `index.html` 파일
  + `main.css` 파일
  + `graphic.jpg` 파일
+ 웹 사이트 호스팅용으로 구성된 S3 버킷. [Amazon S3에서 정적 웹 사이트 호스팅](https://docs.aws.amazon.com/AmazonS3/latest/userguide/WebsiteHosting.html)을 참조하십시오. 버킷을 파이프라인과 같은 리전에 생성해야 합니다.
**참고**  
웹 사이트를 호스팅하려면 버킷에 퍼블릭 읽기 액세스 권한이 있어야 합니다. 이를 통해 모든 사람에게 읽기 권한이 부여됩니다. 웹 사이트 호스팅을 제외하고 S3 버킷에 대한 퍼블릭 액세스를 차단하는 기본 액세스 설정을 유지해야 합니다.

### 1단계: 소스 파일을 CodeCommit 리포지토리에 푸시
<a name="tutorials-s3deploy-acc-push"></a>

이 단원에서는 파이프라인이 소스 단계에 대해 사용하는 리포지토리에 소스 파일을 푸시합니다.

**CodeCommit 리포지토리에 파일을 푸시하려면**

1. 다운로드한 샘플 파일을 추출합니다. ZIP 파일을 리포지토리에 업로드하지 마십시오.

1. CodeCommit 리포지토리에 파일을 푸시하거나 업로드합니다. 이러한 파일은 **파이프라인 생성** 마법사가 CodePipeline에서 배포 작업을 위해 생성한 소스 아티팩트입니다. 파일은 로컬 디렉터리에 다음과 같이 나타납니다.

   ```
   index.html
   main.css
   graphic.jpg
   ```

1. Git 또는 CodeCommit 콘솔을 사용하여 파일을 업로드할 수 있습니다.

   1. 로컬 컴퓨터의 복제된 리포지토리에서 Git 명령줄을 사용하려면 다음과 같이 합니다.

      1. 다음 명령을 실행하여 모든 파일을 한 번에 스테이징합니다.

         ```
         git add -A
         ```

      1. 다음 명령을 실행하여 커밋 메시지와 함께 파일을 커밋합니다.

         ```
         git commit -m "Added static website files"
         ```

      1. 다음 명령을 실행하여 로컬 리포지토리의 파일을 CodeCommit 리포지토리에 푸시합니다.

         ```
         git push
         ```

   1. CodeCommit 콘솔을 사용하여 파일을 업로드하려면 다음과 같이 합니다.

      1. CodeCommit 콘솔을 열고 **리포지토리** 목록에서 해당 리포지토리를 선택합니다.

      1. **파일 추가**를 선택한 후 **파일 업로드**를 선택합니다.

      1. **파일 선택**을 선택한 다음 파일을 찾습니다. 사용자 이름과 이메일 주소를 입력하여 변경 사항을 커밋합니다. **변경 사항 커밋**을 선택합니다.

      1. 업로드하려는 각 파일에 대해 이 단계를 반복합니다.

### 2단계: 파이프라인 생성
<a name="tutorials-s3deploy-acc-pipeline"></a>

이 단원에서는 다음 작업을 통해 파이프라인을 생성합니다.
+ 소스 아티팩트가 웹 사이트용 파일인 CodeCommit 작업이 있는 소스 단계.
+ Amazon S3 배포 작업이 적용된 배포 단계.

**마법사를 사용하여 파이프라인을 생성하려면**

1. 에 로그인 AWS Management Console 하고 [http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) CodePipeline 콘솔을 엽니다.

1. **Welcome(시작)** 페이지, **시작하기** 페이지 또는 **Pipelines(파이프라인)** 페이지에서 **파이프라인 생성**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 **MyS3DeployPipeline**을 입력합니다.

1. **파이프라인 유형**에서 **V2**를 선택합니다. 자세한 내용은 [파이프라인 유형](pipeline-types.md) 단원을 참조하십시오. **다음**을 선택합니다.

1. **서비스 역할**에서 **새 서비스 역할**을 선택하여CodePipeline이 IAM에 서비스 역할을 생성하도록 허용합니다.

1. [**Advanced settings**]의 설정은 기본값 그대로 두고, [**Next**]를 선택합니다.

1. **3단계: 소스 스테이지 추가**의 **소스 공급자**에서 **AWS CodeCommit**을 선택합니다. **리포지토리 이름**에서 [1단계: CodeCommit 리포지토리 생성](tutorials-simple-codecommit.md#codecommit-create-repository)에서 생성한 CodeCommit 리포지토리의 이름을 선택합니다. [**Branch name**]에서 가장 마지막 코드 업데이트가 포함된 브랜치의 이름을 선택합니다. 사용자가 자체적으로 다른 브랜치를 생성하지 않았다면 `main`만 선택할 수 있습니다.

   리포지토리 이름과 브랜치를 선택하면 이 파이프라인에 대해 생성될 Amazon CloudWatch Events 규칙이 표시됩니다.

   **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가**에서 **빌드 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **6단계: 배포 단계 추가**에서:

   1. **Deploy provider(배포 공급자)**에서 **Amazon S3**를 선택합니다.

   1. **버킷**에 퍼블릭 버킷 이름을 입력합니다.

   1. **Extract file before deploy(배포 전 파일 추출)**를 선택합니다.
**참고**  
**Extract file before deploy(배포 전 파일 추출)**를 선택하지 않으면 배포가 실패합니다. 이는 파이프라인의 AWS CodeCommit 작업이 소스 아티팩트를 압축하고 파일이 ZIP 파일이기 때문입니다.

      **Extract file before deploy(배포 전 파일 추출)**를 선택하면 **Deployment path(배포 경로)**가 표시됩니다. 사용할 경로의 이름을 입력합니다. 그러면 파일이 추출되는 Amazon S3에 폴더 구조가 생성됩니다. 이 자습서에서는 이 필드를 비워 둡니다.  
![\[6단계: 소스가 있는 S3 배포 작업에 대한 배포 단계 추가 페이지 S3 AWS CodeCommit\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/tutorial-s3deploy-stage-codecommit.png)

   1. (선택 사항) **표준 ACL**에서 [표준 ACL](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl)이라고 하는 미리 정의된 일련의 권한 부여를 업로드된 아티팩트에 적용할 수 있습니다.

   1. (선택 사항) **캐시 제어**에 캐싱 파라미터를 입력합니다. 요청/응답에 대한 캐싱 동작을 제어하도록 이를 설정할 수 있습니다. 유효한 값의 경우 HTTP 작업에 대한 [http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9) 헤더 필드를 확인합니다.

   1. **다음**을 선택합니다.

1. **7단계: 검토**에서 정보를 검토한 다음 **파이프라인 생성을** 선택합니다.

1. 파이프라인이 성공적으로 실행된 후 Amazon S3 콘솔을 열고 파일이 다음과 같이 퍼블릭 버킷에 나타나는지 확인합니다.

   ```
   index.html
   main.css
   graphic.jpg
   ```

1. 엔드포인트에 액세스하여 웹 사이트를 테스트합니다. 엔드포인트의 형식은 다음과 같습니다. `http://bucket-name.s3-website-region.amazonaws.com/` 

   엔드포인트 예제: `http://my-bucket.s3-website-us-west-2.amazonaws.com/`.

   샘플 웹페이지가 표시됩니다.

### 3단계: 모든 소스 파일을 변경하고 배포 확인
<a name="tutorials-s3deploy-acc-update"></a>

소스 파일을 변경한 후 변경 사항을 리포지토리에 푸시합니다. 이렇게 하면 파이프라인이 실행됩니다. 웹 사이트가 업데이트되었는지 확인합니다.

## 옵션 2: S3 소스 버킷에서 Amazon S3에 빌드된 아카이브 파일 배포
<a name="tutorials-s3deploy-s3source"></a>

이 옵션에서 빌드 단계의 빌드 명령은 TypeScript 코드를 JavaScript 코드로 컴파일하고 별도의 타임스탬프 폴더 아래에 있는 S3 대상 버킷에 출력을 배포합니다. 먼저 TypeScript 코드와 buildspec.yml 파일을 생성합니다. ZIP 파일의 소스 파일을 결합한 후에 소스 ZIP 파일을 S3 소스 버킷에 업로드하고, CodeBuild 단계를 사용하여 빌드된 애플리케이션 ZIP 파일을 S3 대상 버킷에 배포합니다. 컴파일된 코드는 대상 버킷에 아카이브로 보관됩니다.

### 사전 조건
<a name="tutorials-s3deploy-s3source-prereq"></a>

다음 항목이 있어야 합니다.
+ S3 소스 버킷. [자습서: 간단한 파이프라인 생성(S3 버킷)](tutorials-simple-s3.md)에서 생성한 버킷을 사용할 수 있습니다.
+ S3 대상 버킷. [Amazon S3에서 정적 웹 사이트 호스팅](https://docs.aws.amazon.com/AmazonS3/latest/userguide/WebsiteHosting.html)을 참조하십시오. 생성하려는 파이프라인 AWS 리전 과 동일한에서 버킷을 생성해야 합니다.
**참고**  
이 예제는 파일을 프라이빗 버킷에 배포하는 방법을 보여 줍니다. 웹 사이트 호스팅용 대상 버킷을 활성화하거나 버킷을 공개하는 정책을 연결하지 마십시오.

### 1단계: 소스 파일을 생성하고 S3 소스 버킷에 업로드
<a name="tutorials-s3deploy-s3source-upload"></a>

이 단원에서는 파이프라인이 소스 단계에 대해 사용하는 버킷에 소스 파일을 생성하고 업로드합니다. 이 단원에서는 다음 소스 파일을 생성하는 방법에 대해 설명합니다.
+ CodeBuild 빌드 프로젝트에 사용되는 `buildspec.yml` 파일.
+ `index.ts` 파일.

**buildspec.yml 파일을 만들려면**
+ 다음 콘텐츠를 가진 `buildspec.yml`이라는 파일을 생성합니다: 이러한 빌드 명령은 TypeScript를 설치하고 TypeScript 컴파일러를 사용하여 `index.ts`의 코드를 JavaScript 코드로 다시 작성합니다.

  ```
  version: 0.2
  
  phases:
    install:
      commands:
        - npm install -g typescript
    build:
      commands:
        - tsc index.ts
  artifacts:
    files:
      - index.js
  ```

**index.ts 파일을 만들려면**
+ 다음 콘텐츠를 가진 `index.ts`이라는 파일을 생성합니다:

  ```
  interface Greeting {
      message: string;
  }
  
  class HelloGreeting implements Greeting {
      message = "Hello!";
  }
  
  function greet(greeting: Greeting) {
      console.log(greeting.message);
  }
  
  let greeting = new HelloGreeting();
  
  greet(greeting);
  ```

**S3 소스 버킷에 파일을 업로드하려면**

1. 파일은 로컬 디렉터리에 다음과 같이 나타납니다.

   ```
   buildspec.yml
   index.ts
   ```

   파일을 압축하고 해당 파일의 이름을 `source.zip`으로 지정합니다.

1. Amazon S3 콘솔에서 소스 버킷에 대해 **업로드**를 선택합니다. **파일 추가**를 선택한 다음 생성한 ZIP 파일을 찾습니다.

1.  **업로드**를 선택합니다. 이러한 파일은 **파이프라인 생성** 마법사가 CodePipeline에서 배포 작업을 위해 생성한 소스 아티팩트입니다. 파일은 버킷에 다음과 같이 나타납니다.

   ```
   source.zip
   ```

### 2단계: 파이프라인 생성
<a name="tutorials-s3deploy-s3source-pipeline"></a>

이 단원에서는 다음 작업을 통해 파이프라인을 생성합니다.
+ 소스 아티팩트가 다운로드 가능한 애플리케이션용 파일인 Amazon S3 작업이 있는 소스 단계.
+ Amazon S3 배포 작업이 적용된 배포 단계.

**마법사를 사용하여 파이프라인을 생성하려면**

1. 에 로그인 AWS Management Console 하고 [http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) CodePipeline 콘솔을 엽니다.

1. **Welcome(시작)** 페이지, **시작하기** 페이지 또는 **Pipelines(파이프라인)** 페이지에서 **파이프라인 생성**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 **MyS3DeployPipeline**을 입력합니다.

1. **서비스 역할**에서 **새 서비스 역할**을 선택하여CodePipeline이 IAM에 서비스 역할을 생성하도록 허용합니다.

1. [**Advanced settings**]의 설정은 기본값 그대로 두고, [**Next**]를 선택합니다.

1. **3단계: 소스 스테이지 추가**의 **소스 공급자**에서 **Amazon S3**를 선택합니다. **Bucket(버킷)**에서 소스 버킷의 이름을 선택합니다. **S3 object key(S3 객체 키)**에 소스 ZIP 파일의 이름을 입력합니다. .zip 파일 확장명을 포함해야 합니다.

   **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가**에서 다음과 같이 합니다.

   1. **빌드 공급자**에서 **CodeBuild**를 선택합니다.

   1. **빌드 프로젝트 생성**을 선택합니다. **Create project(프로젝트 생성)** 페이지:

   1. **프로젝트 이름**에 이 빌드 프로젝트의 이름을 입력합니다.

   1. **환경**에서 **Managed image(관리형 이미지)**를 선택합니다. [**Operating system**]에서 [**Ubuntu**]를 선택합니다.

   1. **실행 시간**에서 **표준**을 선택합니다. **실행 시간 버전**에서 **aws/codebuild/standard:1.0**을 선택합니다.

   1. **Image version(이미지 버전)**에서 **Always use the latest image for this runtime version(이 실행 시간 버전에 항상 최신 이미지 사용)**을 선택합니다.

   1. **서비스 역할**에 CodeBuild 서비스 역할을 선택하거나 하나 생성합니다.

   1. **Build specifications(빌드 사양)**에서 **Use a buildspec file(빌드 사양 파일 사용)**을 선택합니다.

   1. **Continue to CodePipeline(CodePipeline으로 계속)**을 선택합니다. 프로젝트가 성공적으로 생성되면 메시지가 표시됩니다.

   1. **다음**을 선택합니다.

1. **5단계: 배포 스테이지 추가**에서 다음과 같이 합니다.

   1. **Deploy provider(배포 공급자)**에서 **Amazon S3**를 선택합니다.

   1. **Bucket(버킷)**에 S3 대상 버킷 이름을 입력합니다.

   1. **Extract file before deploy(배포 전 파일 추출)**를 선택 해제해야 합니다.

      **Extract file before deploy(배포 전 파일 추출)**를 선택 해제하면 **S3 object key(S3 객체 키)**가 표시됩니다. 사용할 경로의 이름 `js-application/{datetime}.zip`을 입력합니다.

      그러면 파일이 추출되는 Amazon S3에 `js-application` 폴더가 생성됩니다. 이 폴더에서 파이프라인이 실행될 때 `{datetime}` 변수는 각 출력 파일에 타임스탬프를 생성합니다.  
![\[Amazon S3 소스가 포함된 Amazon S3 배포 작업의 5단계: 배포 페이지\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/tutorial-s3deploy-stage-s3source.png)

   1. (선택 사항) **표준 ACL**에서 [표준 ACL](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl)이라고 하는 미리 정의된 일련의 권한 부여를 업로드된 아티팩트에 적용할 수 있습니다.

   1. (선택 사항) **캐시 제어**에 캐싱 파라미터를 입력합니다. 요청/응답에 대한 캐싱 동작을 제어하도록 이를 설정할 수 있습니다. 유효한 값의 경우 HTTP 작업에 대한 [http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9) 헤더 필드를 확인합니다.

   1. **다음**을 선택합니다.

1. **6단계: 검토**에서 정보를 검토한 다음, **파이프라인 생성**을 선택합니다.

1. 파이프라인이 성공적으로 실행되면 Amazon S3 콘솔에서 버킷을 봅니다. 배포된 ZIP 파일이 `js-application` 폴더 아래의 대상 버킷에 표시되는지 확인합니다. ZIP 파일에 포함된 JavaScript 파일은 `index.js`여야 합니다. `index.js` 파일에는 다음 출력이 포함되어 있습니다.

   ```
   var HelloGreeting = /** @class */ (function () {
       function HelloGreeting() {
           this.message = "Hello!";
       }
       return HelloGreeting;
   }());
   function greet(greeting) {
       console.log(greeting.message);
   }
   var greeting = new HelloGreeting();
   greet(greeting);
   ```

### 3단계: 모든 소스 파일을 변경하고 배포 확인
<a name="tutorials-s3deploy-s3source-update"></a>

소스 파일을 변경한 후 소스 버킷에 업로드합니다. 이렇게 하면 파이프라인이 실행됩니다. 대상 버킷을 보고 다음과 같이 배포된 출력 파일을 `js-application` 폴더에서 사용할 수 있는지 확인합니다.

![\[샘플 ZIP 다운로드\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/tutorial-s3deploy-pipeline-appzip.png)


# 자습서: 서버리스 애플리케이션을에 게시하는 파이프라인 생성 AWS Serverless Application Repository
<a name="tutorials-serverlessrepo-auto-publish"></a>

 AWS CodePipeline 를 사용하여 AWS SAM 서버리스 애플리케이션을에 지속적으로 전달할 수 있습니다 AWS Serverless Application Repository.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

이 자습서에서는 GitHub에서 호스팅되는 서버리스 애플리케이션을 빌드하고에 AWS Serverless Application Repository 자동으로 게시하도록 파이프라인을 생성하고 구성하는 방법을 보여줍니다. 파이프라인은 GitHub를 소스 공급자로 사용하고 CodeBuild를 빌드 공급자로 사용합니다. 서버리스 애플리케이션을에 게시하려면 [애플리케이션](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~aws-serverless-codepipeline-serverlessrepo-publish )(에서 AWS Serverless Application Repository)을 AWS Serverless Application Repository배포하고 해당 애플리케이션에서 생성한 Lambda 함수를 파이프라인의 호출 작업 공급자로 연결합니다. 그런 다음 코드를 작성하지 AWS Serverless Application Repository않고도에 애플리케이션 업데이트를 지속적으로 제공할 수 있습니다.

**중요**  
이 절차에서 파이프라인에 추가하는 많은 작업에는 파이프라인을 생성하기 전에 생성해야 하는 AWS 리소스가 포함됩니다. 소스 작업에 대한 AWS 리소스는 항상 파이프라인을 생성하는 리전과 동일한 AWS 리전에서 생성해야 합니다. 예를 들어, 미국 동부(오하이오) 리전에서 파이프라인을 생성하는 경우, CodeCommit 리포지토리도 미국 동부(오하이오) 리전에 있어야 합니다.  
파이프라인을 생성할 때 교차 리전 작업을 추가할 수 있습니다. 교차 리전 작업에 대한 AWS 리소스는 작업을 실행하려는 리전과 동일한 AWS 리전에 있어야 합니다. 자세한 내용은 [CodePipeline에 교차 리전 작업 추가](actions-create-cross-region.md) 단원을 참조하십시오.

## 시작하기 전 준비 사항
<a name="tutorials-serverlessrepo-auto-publish-prereq"></a>

이 자습서에서는 다음을 가정합니다.
+ 사용자는 [AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/) 및 [AWS Serverless Application Repository](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/)에 익숙합니다.
+  AWS SAM CLI를 AWS Serverless Application Repository 사용하여에 게시한 서버리스 애플리케이션이 GitHub에서 호스팅되어 있습니다. 예제 애플리케이션을에 게시하려면 *AWS Serverless Application Repository 개발자 안내서*의 [빠른 시작: 애플리케이션 게시](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverlessrepo-quick-start.html)를 AWS Serverless Application Repository참조하세요. 자체 애플리케이션을에 게시하려면 *AWS Serverless Application Model 개발자 안내서*[의 AWS SAM CLI를 사용하여 애플리케이션 게시](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-publishing-applications.html)를 AWS Serverless Application Repository참조하세요.

## 1단계: buildspec.yml 파일 생성
<a name="serverlessrepo-auto-publish-create-buildspec"></a>

다음 내용으로 `buildspec.yml` 파일을 생성하고 서버리스 애플리케이션의 GitHub 리포지토리에 추가합니다. *template.yml*을 애플리케이션의 AWS SAM 템플릿으로 바꾸고 *bucketname*을 패키지 애플리케이션이 저장된 S3 버킷으로 바꿉니다.

```
version: 0.2
phases:
  install:
    runtime-versions:
        python: 3.8
  build:
    commands:
      - sam package --template-file template.yml --s3-bucket bucketname --output-template-file packaged-template.yml
artifacts:
  files:
    - packaged-template.yml
```

## 2단계: 파이프라인 생성 및 구성
<a name="serverlessrepo-auto-publish-create-pipeline"></a>

다음 단계에 따라 서버리스 애플리케이션을 게시 AWS 리전 하려는에서 파이프라인을 생성합니다.

1. 에 로그인 AWS Management Console 하고 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) CodePipeline 콘솔을 엽니다.

1. 필요한 경우 서버리스 애플리케이션을 게시 AWS 리전 할 로 전환합니다.

1. [**Welcome**] 페이지, [**Getting started**] 페이지 또는 [**Pipelines**] 페이지에서 **Create pipeline(파이프라인 생성)**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. [**파이프라인 생성**]을 선택합니다. **2단계: 파이프라인 설정 선택** 페이지의 **파이프라인 이름**에 파이프라인 이름을 입력합니다.

1. **파이프라인 유형**에서 **V2**를 선택합니다. 자세한 내용은 [파이프라인 유형](pipeline-types.md) 단원을 참조하십시오. **다음**을 선택합니다.

1. **서비스 역할**에서 **새 서비스 역할**을 선택하여CodePipeline이 IAM에 서비스 역할을 생성하도록 허용합니다.

1. [**Advanced settings**]의 설정은 기본값 그대로 두고, [**Next**]를 선택합니다.

1. **3단계: 소스 스테이지 추가** 페이지의 **소스 공급자**에서 **GitHub**를 선택합니다.

1. **연결**에서 기존 연결을 선택하거나 새로 생성합니다. GitHub 소스 작업에 대한 연결을 만들거나 관리하려면 [GitHub 연결](connections-github.md)을 참조하세요.

1. **리포지토리**에서 GitHub 소스 리포지토리를 선택합니다.

1. **브랜치**에서 GitHub 브랜치를 선택합니다.

1. 소스 작업의 나머지 기본값은 그대로 둡니다. **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가** 페이지에서 빌드 스테이지를 추가합니다.

   1. **빌드 공급자**에서 **AWS CodeBuild**를 선택합니다. **리전**에서 파이프라인 리전을 사용합니다.

   1. **프로젝트 생성**을 선택합니다.

   1. **프로젝트 이름**에 이 빌드 프로젝트의 이름을 입력합니다.

   1. **환경 이미지**에서 **이미지 관리**를 선택합니다. [**Operating system**]에서 [**Ubuntu**]를 선택합니다.

   1. **실행 시간** 및 **실행 시간 버전**에서 서버리스 애플리케이션에 필요한 런타임 및 버전을 선택합니다.

   1. **서비스 역할**에서 **New service role(새 서비스 역할)**을 선택합니다.

   1. **Build specifications(빌드 사양)**에서 **Use a buildspec file(빌드 사양 파일 사용)**을 선택합니다.

   1. **Continue to CodePipeline(CodePipeline으로 계속)**을 선택합니다. 이렇게 하면 CodePipeline 콘솔이 열리고 구성을 위해 리포지토리에서 `buildspec.yml`을 사용하는 CodeBuild 프로젝트를 생성합니다. 빌드 프로젝트가 서비스 역할을 사용하여 AWS 서비스 권한을 관리합니다. 이 단계는 몇 분이 걸릴 수 있습니다.

   1. **다음**을 선택합니다.

1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **6단계: 배포 단계 추가** 페이지에서 **배포 단계 건너뛰기를** 선택한 다음 다시 **건너뛰기를** 선택하여 경고 메시지를 수락합니다. **다음**을 선택합니다.

1. **7단계: 검토**에서 **파이프라인 생성을** 선택합니다. 스테이지를 보여주는 다이어그램을 확인해야 합니다.

1. 패키지 애플리케이션이 저장된 S3 버킷에 액세스하려면 CodeBuild 서비스 역할 권한을 부여합니다.

   1. 새 파이프라인의 **빌드** 단계에서 **CodeBuild**를 선택합니다.

   1. **Build details(빌드 세부 정보)** 탭을 선택합니다.

   1. **환경**에서 CodeBuild 서비스 역할을 선택하여 IAM 콘솔을 엽니다.

   1. `CodeBuildBasePolicy`에 대한 선택을 확장하고 **Edit policy(정책 편집)**을 선택합니다.

   1. **JSON**을 선택합니다.

   1. 다음 내용으로 새 정책문을 추가합니다. 이 정책문을 사용하여 CodeBuild가 패키징된 애플리케이션이 저장된 S3 버킷에 객체를 넣을 수 있습니다. *bucketname*을 S3 버킷 이름으로 바꿉니다.

      ```
              {
                  "Effect": "Allow",
                  "Resource": [
                      "arn:aws:s3:::bucketname/*"
                  ],
                  "Action": [
                      "s3:PutObject"
                  ]
              }
      ```

   1. **정책 검토**를 선택합니다.

   1. **변경 사항 저장**을 선택합니다.

## 3단계: 게시 애플리케이션 배포
<a name="serverlessrepo-auto-publish-deploy-app"></a>

 AWS Serverless Application Repository에 게시를 수행하는 Lambda 함수가 포함된 애플리케이션을 배포하려면 다음 단계를 수행하세요. 이 애플리케이션은 **aws-serverless-codepipeline-serverlessrepo-publish**입니다.

**참고**  
파이프라인 AWS 리전 과 동일한에 애플리케이션을 배포해야 합니다.

1. [애플리케이션](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~aws-serverless-codepipeline-serverlessrepo-publish ) 페이지로 이동하고 **배포**를 선택합니다.

1. **I acknowledge that this app creates custom IAM roles(이 앱에서 사용자 지정 IAM 역할을 생성하는 것을 확인합니다)**를 선택합니다.

1. **배포(Deploy)**를 선택합니다.

1. ** CloudFormation 스택 보기를** 선택하여 CloudFormation 콘솔을 엽니다.

1. **리소스** 섹션을 확장합니다. **AWS::Lambda::Function** 유형의 **ServerlessRepoPublish**가 표시됩니다. 다음 단계에서 이 리소스의 물리적 ID를 적어 둡니다. CodePipeline에서 새 게시 작업을 생성할 때 이 물리적 ID를 사용합니다.

## 4단계: 게시 작업 생성
<a name="serverlessrepo-auto-publish-create-action"></a>

다음 단계에 따라 파이프라인에 게시 작업을 생성합니다.

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔을 엽니다.

1. 왼쪽 탐색 섹션에서 편집하려는 파이프라인을 선택합니다.

1. **편집**을 선택합니다.

1. 현재 파이프라인의 마지막 스테이지 후 **\$1 Add stage(\$1 스테이지 추가)**를 선택합니다. **Stage name(스테이지 이름)**에서 이름(예: **Publish**)을 입력하고 **Add stage(스테이지 추가)**를 선택합니다.

1. 새 단계에서 **\$1 Add action group(작업 그룹 추가)**을 선택합니다.

1. 작업 이름을 입력합니다. **Action provider(작업 공급자)**의 **호출**에서 **AWS Lambda**을 선택합니다.

1. **입력 아티팩트**에서 **BuildArtifact**를 선택합니다.

1. **함수 이름**에서 이전 단계에서 기록한 Lambda 함수의 물리적 ID를 선택합니다.

1. 작업에 대해 **저장**을 선택합니다.

1. 스테이지에 대해 **완료**를 선택합니다.

1. 오른쪽 상단에서 **저장**을 선택합니다.

1. 파이프라인을 확인하려면 GitHub에서 애플리케이션을 변경합니다. 예를 들어 AWS SAM 템플릿 파일의 `Metadata` 섹션에서 애플리케이션 설명을 변경합니다. 변경 사항을 커밋하고 GitHub 브랜치로 푸시합니다. 이렇게 하면 파이프라인이 실행됩니다. 파이프라인이 완료되면 애플리케이션이 [AWS Serverless Application Repository](https://console.aws.amazon.com/serverlessrepo/home)에서 변경 사항으로 업데이트 되었는지 확인합니다.

# 자습서: CodePipeline을 사용한 Lambda 함수 배포
<a name="tutorials-lambda-deploy"></a>

이 자습서는 CodePipeline에서 Lambda에 구성한 함수로 코드를 배포하는 배포 작업을 생성하는 방법을 안내합니다. 별칭 및 버전을 생성하고, 소스 위치에 압축된 Lambda 함수를 추가하고, 파이프라인에서 Lambda 작업을 실행할 샘플 Lambda 함수를 생성합니다.

**참고**  
콘솔에서 파이프라인을 생성하는 과정에서 CodePipeline은 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

**참고**  
`Lambda` 배포 작업은 V2 유형 파이프라인에서만 사용할 수 있습니다.

## 사전 조건
<a name="tutorials-lambda-deploy-prereqs"></a>

이 자습서를 이용하여 CD 파이프라인을 만들려면 먼저 몇 가지 리소스를 갖춰야 합니다. 다음은 시작하기 위해 필요한 항목입니다.

**참고**  
이러한 모든 리소스는 동일한 AWS 리전 내에 생성되어야 합니다.
+ GitHub와 같은 소스 제어 리포지토리 또는 Lambda 함수에 대해 생성한 `.zip` 파일을 저장할 소스 S3 버킷(이 자습서에서는 S3 사용).
+ 이 작업에 대한 권한으로 업데이트된 기존 CodePipeline 서비스 역할을 사용해야 합니다. 서비스 역할을 업데이트하려면 [Lambda 배포 작업에 대한 서비스 역할 정책 권한](action-reference-LambdaDeploy.md#action-reference-LambdaDeploy-permissions-action) 섹션을 참조하세요.

이러한 사전 조건을 모두 갖췄으면 이제 자습서를 이용하여 CD 파이프라인을 만들 수 있습니다.

## 1단계: 샘플 Lambda 함수 생성
<a name="tutorials-lambda-deploy-instances"></a>

이 단계에서는 배포할 Lambda 함수를 생성합니다.

**Lambda 함수를 만들려면**

1. Lambda 콘솔에 액세스하고 다음 자습서의 단계에 따라 샘플 Lambda 함수 link를 생성합니다.

1. 상단 탐색에서 **생성**을 선택하고 페이지 상단에서 **처음부터 시작**을 선택합니다.

1. **이름**에 **MyLambdaFunction**를 입력합니다.

1. 새 버전을 게시합니다. 별칭이 가리키는 버전이 됩니다.

   1. 함수를 선택합니다.

   1. **작업** 드롭다운을 선택합니다.

   1. [**새 버전 발행**]을 선택합니다.

   1. (선택 사항) 설명에서 **설명**을 추가합니다.

   1. **게시**를 선택합니다.

1. `aliasV1`과 같이 함수의 별칭을 생성합니다.

1. 별칭이 방금 생성한 버전(예: 1)을 가리키는지 확인합니다.
**참고**  
\$1LATEST를 선택하면 Lambda가 둘 이상의 버전을 가리키는 별칭에 대해 \$1LATEST를 지원하지 않으므로 트래픽 이동 기능을 사용할 수 없습니다.

## 2단계: 리포지토리에 함수 파일 업로드
<a name="tutorials-lambda-deploy-file"></a>

함수를 다운로드하여 zip 파일로 저장합니다. 다음 단계에 따라 압축된 파일을 S3 버킷에 업로드합니다.

**`.zip` 파일을 해당 소스 리포지토리에 추가하려면**

1. S3 버킷을 엽니다.

1. **업로드**를 선택합니다.

1. `sample_lambda_source.zip` 파일이 포함된 zip 파일을 소스 버킷에 업로드합니다.

   경로를 기록해 둡니다.

   ```
   object key
   ```

## 3단계: 파이프라인 생성
<a name="tutorials-lambda-deploy-pipeline"></a>

CodePipeline 마법사를 사용하여 파이프라인 스테이지를 생성하고, 소스 리포지토리를 연결합니다.

**파이프라인을 생성하려면**

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔을 엽니다.

1. [**Welcome**] 페이지, [**Getting started**] 페이지 또는 [**Pipelines**] 페이지에서 **Create pipeline(파이프라인 생성)**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 **MyPipeline**을 입력합니다.

1. CodePipeline은 특성과 가격이 다른 V1 및 V2 유형 파이프라인을 제공합니다. V2 유형은 콘솔에서 선택할 수 있는 유일한 유형입니다. 자세한 내용은 [파이프라인 유형](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)을 참조하세요. CodePipeline에 대한 요금 정보는 [요금](https://aws.amazon.com/codepipeline/pricing/)을 참조하세요.

1. **서비스 역할**에서 **기존 서비스 역할 사용**을 선택한 다음이 작업에 필요한 권한으로 업데이트된 CodePipeline 서비스 역할을 선택합니다. 이 작업에 대한 CodePipeline 서비스 역할을 구성하려면 [Lambda 배포 작업에 대한 서비스 역할 정책 권한](action-reference-LambdaDeploy.md#action-reference-LambdaDeploy-permissions-action) 섹션을 참조하세요.

1. [**Advanced settings**]의 설정은 기본값 그대로 두고, [**Next**]를 선택합니다.

1. **3단계: 소스 스테이지 추가** 페이지에서 소스 스테이지를 추가합니다.

   1. **소스 공급자**에서 **Amazon S3**를 선택합니다.

   1. **객체 키**에 `sample_lambda_source.zip`과 같은 파일 확장명을 포함하여 .zip 파일의 이름을 추가합니다.

      

   **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가** 페이지에서 **건너뛰기**를 선택합니다.

1. **5단계: 테스트 스테이지 추가** 페이지에서 **건너뛰기**를 선택합니다.

1. **6단계: 배포 스테이지 추가** 페이지에서 **Lambda**를 선택합니다.  
![\[\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/lambdadeploy-edit-screen.png)

   1. 함수 이름과 별칭을 추가합니다.

   1. 배포 전략을 선택합니다.

   1. **다음**을 선택합니다.

1. **7단계: 검토** 페이지에서 파이프라인 구성을 검토하고 **파이프라인 생성을** 선택하여 파이프라인을 생성합니다.  
![\[\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/lambdadeploy-pipeline-screen.png)

## 4단계: 파이프라인 테스트
<a name="tutorials-lambda-deploy-test"></a>

파이프라인에는 end-to-end네이티브 AWS 지속적 배포를 실행하기 위한 모든 것이 있어야 합니다. 이제 소스 리포지토리에 코드 변경을 푸시하여 파이프라인 기능을 테스트해 보겠습니다.

**파이프라인을 테스트하려면**

1. 구성된 소스 리포지토리에 대한 코드를 변경하고 커밋한 후 변경 사항을 푸시합니다.

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔을 엽니다.

1. 목록에서 파이프라인을 선택합니다.

1. 단계를 수행하면서 파이프라인 진행 상황을 관찰합니다. 파이프라인이 완료되고 작업이 Lambda 함수에 배포됩니다.

## 자세히 알아보기
<a name="tutorials-lambda-deploy-learn"></a>

Lambda 배포 작업은 두 가지 배포 방법을 허용합니다. 한 가지 방법은 소스 작업의 입력 아티팩트 없이 트래픽만 이동하는 것입니다. 다른 방법은 소스 작업의 입력 아티팩트를 사용하여 함수 코드를 업데이트한 다음 업데이트된 코드를 기반으로 새 버전을 게시하는 것입니다. 두 번째 방법의 경우 별칭이 제공되면 CodePipeline은 트래픽 이동도 수행합니다. 이 Lambda 배포 작업 자습서에서는 소스 아티팩트를 사용하여 함수를 업데이트하는 방법을 보여줍니다.

작업에 대한 자세한 내용은 [AWS Lambda 배포 작업 참조](action-reference-LambdaDeploy.md)에서 작업 참조 페이지를 참조하세요.

# 자습서: Lambda 호출 작업과 함께 변수 사용
<a name="tutorials-lambda-variables"></a>

Lambda 호출 작업은 입력의 일부로 다른 작업의 변수를 사용하고 출력과 함께 새로운 변수를 반환할 수 있습니다. CodePipeline의 작업 변수에 대한 자세한 내용은 [변수 참조](reference-variables.md) 단원을 참조하십시오.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

이 자습서의 마지막에서는 다음 항목을 갖게 됩니다.
+ 다음과 같은 Lambda 호출 작업:
  + CodeCommit 소스 동작에서 `CommitId` 변수 사용
  + `dateTime`, `testRunId` 및 `region`의 세 가지 새 변수 출력
+ Lambda 호출 작업의 새 변수를 사용하여 테스트 URL 및 테스트 실행 ID를 제공하는 수동 승인 작업
+ 새 작업으로 업데이트된 파이프라인

**Topics**
+ [사전 조건](#lambda-variables-prereqs)
+ [1단계: Lambda 함수 생성](#lambda-variables-function)
+ [2단계: 파이프라인에 Lambda 호출 작업 및 수동 승인 작업 추가](#lambda-variables-pipeline)

## 사전 조건
<a name="lambda-variables-prereqs"></a>

시작하기 전에 다음을 완비해야 합니다.
+ [자습서: 간단한 파이프라인 생성(CodeCommit 리포지토리)](tutorials-simple-codecommit.md)에서 CodeCommit 소스와 함께 파이프라인을 생성하거나 사용할 수 있습니다.
+ CodeCommit 소스 작업에 네임스페이스가 있도록 기존 파이프라인을 편집합니다. 작업에 `SourceVariables` 네임스페이스를 할당합니다.

## 1단계: Lambda 함수 생성
<a name="lambda-variables-function"></a>

Lambda 함수 및 Lambda 실행 역할을 만들려면 다음 단계를 따르세요. Lambda 함수를 만든 후 파이프라인에 Lambda 작업을 추가합니다.

**Lambda 함수 및 실행 역할을 생성하려면**

1. 에 로그인 AWS Management Console 하고 [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) AWS Lambda 콘솔을 엽니다.

1. **함수 생성**을 선택합니다. **Author from scratch(새로 작성)**를 선택합니다.

1. **Function name(함수 이름)**에 **myInvokeFunction**과 같은 함수 이름을 입력합니다. **Runtime(실행 시간)**에서 기본 옵션을 선택된 상태로 둡니다.

1. **실행 역할 선택 또는 생성**을 확장합니다. **기본 Lambda 권한을 가진 새 역할 생성**을 선택합니다.

1. **함수 생성**을 선택합니다.

1. 다른 작업의 변수를 사용하려면 이 변수를 Lambda 호출 작업 구성에서 `UserParameters`에 전달해야 합니다. 자습서의 뒷부분에서 파이프라인에 작업을 구성하지만 변수가 전달될 것으로 가정하여 코드를 추가합니다.

   새 변수를 생성하려면 입력에서 `outputVariables`라는 속성을 `putJobSuccessResult`로 설정합니다. `putJobFailureResult`의 일부로 변수를 생성할 수 없습니다.

   ```
    const putJobSuccess = async (message) => {
           const params = {
               jobId: jobId,
               outputVariables: {
                   testRunId: Math.floor(Math.random() * 1000).toString(),
                   dateTime: Date(Date.now()).toString(),
                   region: lambdaRegion
               }
           };
   ```

   새 함수의 **코드** 탭에서 `index.mjs` 아래에 다음 예제 코드를 붙여 넣습니다.

   ```
   import { CodePipeline } from '@aws-sdk/client-codepipeline';
   
   export const handler = async (event, context) => {
       const codepipeline = new CodePipeline({});
       
       // Retrieve the Job ID from the Lambda action
       const jobId = event["CodePipeline.job"].id;
       
       // Retrieve UserParameters
       const params = event["CodePipeline.job"].data.actionConfiguration.configuration.UserParameters;
       
       // The region from where the lambda function is being executed
       const lambdaRegion = process.env.AWS_REGION;
       
       // Notify CodePipeline of a successful job
       const putJobSuccess = async (message) => {
           const params = {
               jobId: jobId,
               outputVariables: {
                   testRunId: Math.floor(Math.random() * 1000).toString(),
                   dateTime: Date(Date.now()).toString(),
                   region: lambdaRegion
               }
           };
           
           try {
               await codepipeline.putJobSuccessResult(params);
               return message;
           } catch (err) {
               throw err;
           }
       };
       
       // Notify CodePipeline of a failed job
       const putJobFailure = async (message) => {
           const params = {
               jobId: jobId,
               failureDetails: {
                   message: JSON.stringify(message),
                   type: 'JobFailed',
                   externalExecutionId: context.invokeid
               }
           };
           
           try {
               await codepipeline.putJobFailureResult(params);
               throw message;
           } catch (err) {
               throw err;
           }
       };
       
       try {
           console.log("Testing commit - " + params);
           
           // Your tests here
           
           // Succeed the job
           return await putJobSuccess("Tests passed.");
       } catch (ex) {
           // If any of the assertions failed then fail the job
           return await putJobFailure(ex);
       }
   };
   ```

1. 함수가 자동으로 저장되도록 허용합니다.

1. 화면 상단에서 **함수 ARN** 필드에 포함된 Amazon 리소스 이름(ARN)을 복사합니다.

1. 마지막 단계로 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) AWS Identity and Access Management (IAM) 콘솔을 엽니다. Lambda 실행 역할을 수정하여 다음 정책을 추가합니다([AWSCodePipelineCustomActionAccess](https://console.aws.amazon.com/iam/home?region=us-west-2#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAWSCodePipelineCustomActionAccess)). Lambda 실행 역할을 생성하거나 역할 정책을 수정하는 단계는 [2단계: Lambda 함수 생성](actions-invoke-lambda-function.md#actions-invoke-lambda-function-create-function) 단원을 참조하십시오.

## 2단계: 파이프라인에 Lambda 호출 작업 및 수동 승인 작업 추가
<a name="lambda-variables-pipeline"></a>

이 단계에서는 파이프라인에 Lambda 호출 작업을 추가합니다. [**Test(테스트)**]라는 단계의 일부로 작업을 추가합니다. 작업 유형은 호출 작업입니다. 그런 다음 호출 작업 후 수동 승인 작업을 추가합니다.

**파이프라인에 Lambda 작업 및 수동 승인 작업을 추가하는 방법**

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔을 엽니다.

    AWS 계정과 연결된 모든 파이프라인의 이름이 표시됩니다. 작업을 추가할 파이프라인을 선택합니다.

1. 파이프라인에 Lambda 테스트 작업을 추가합니다.

   1. 파이프라인을 편집하기 위해 **편집**을 선택합니다. 기존 파이프라인에서 소스 작업 이후에 단계를 추가합니다. 단계 이름을 입력합니다(예:**Test**).

   1. 새 스테이지에서 **작업 그룹 추가**를 선택하여 작업을 추가합니다. **Action name(작업 이름)**에 호출 작업의 이름을 입력합니다(예: **Test\$1Commit**).

   1. **작업 공급자**에서 **AWS Lambda**을 선택합니다.

   1. **Input artifacts(입력 아티팩트)**에서 소스 작업의 출력 아티팩트 이름을 선택합니다(예: `SourceArtifact`).

   1. **FunctionName**에 생성한 Lambda 함수의 ARN을 추가합니다.

   1. **Variable namespace(변수 네임스페이스)**에 **TestVariables**와 같은 네임스페이스 이름을 추가합니다.

   1. **출력 아티팩트**에서 **LambdaArtifact**와 같은 출력 아티팩트 이름을 추가합니다.

   1. **완료**를 선택합니다.

1. 파이프라인에 수동 승인 작업을 추가합니다.

   1. 파이프라인이 편집 모드 상태인 경우, 호출 작업 후에 단계를 추가합니다. 단계 이름을 입력합니다(예:**Approval**).

   1. 새 단계에서 아이콘을 선택하여 작업을 추가합니다. **Action name(작업 이름)**에 승인 작업의 이름을 입력합니다(예:**Change\$1Approval**).

   1. **Action provider(작업 공급자)**에서 **수동 승인**을 선택합니다.

   1. **URL for review(검토할 URL)**에서 `region` 변수와 `CommitId` 변수에 대한 변수 구문을 추가하여 URL을 구성합니다. 출력 변수를 제공하는 작업에 할당되는 네임스페이스를 사용해야 합니다.

      이 예제의 경우 CodeCommit 작업에 대한 변수 구문을 사용하는 URL의 기본 네임스페이스는 `SourceVariables`입니다. Lambda 리전 출력 변수의 네임스페이스는 `TestVariables`입니다. URL은 다음과 같습니다.

      ```
      https://#{TestVariables.region}.console.aws.amazon.com/codesuite/codecommit/repositories/MyDemoRepo/commit/#{SourceVariables.CommitId}
      ```

      **Comments(설명)**에서 `testRunId` 변수에 대한 변수 구문을 추가하여 승인 메시지 텍스트를 구성합니다. 이 예제의 경우 Lambda `testRunId` 출력 변수에 대한 변수 구문을 사용하는 URL의 네임스페이스는 `TestVariables`입니다. 다음 메시지를 입력합니다.

      ```
      Make sure to review the code before approving this action. Test Run ID: #{TestVariables.testRunId}
      ```

1. **Done(완료)**을 선택하여 작업에 대한 편집 화면을 닫은 다음 **Done(완료)**을 선택하여 해당 단계의 편집 화면을 닫습니다. 파이프라인을 저장하려면 **Done(완료)**을 선택합니다. 이제 완료된 파이프라인에는 소스, 테스트, 승인 및 배포 단계로 구성된 구조가 포함됩니다.

   **Release change(변경 사항 배포)**를 선택하여 파이프라인 구조를 통해 최신 변경 사항을 실행합니다.

1. 파이프라인이 수동 승인 단계에 도달하면 **Review(검토)**를 선택합니다. 해결된 변수는 커밋 ID의 URL로 나타납니다. 승인자는 커밋을 볼 URL을 선택할 수 있습니다.

1. 파이프라인이 성공적으로 실행되면 작업 실행 기록 페이지에서 변수 값을 볼 수도 있습니다.

# 자습서: 파이프라인에서 AWS Step Functions 호출 작업 사용
<a name="tutorials-step-functions"></a>

 AWS Step Functions 를 사용하여 상태 시스템을 생성하고 구성할 수 있습니다. 이 자습서에서는 파이프라인에서 상태 시스템 실행을 활성화하는 파이프라인에 호출 작업을 추가하는 방법을 보여 줍니다.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

이 자습서에서는 다음 태스크를 수행합니다.
+ 에서 표준 상태 시스템을 생성합니다 AWS Step Functions.
+ 상태 시스템 입력 JSON을 직접 입력합니다. 상태 시스템 입력 파일을 Amazon Simple Storage Service(S3) 버킷에 업로드할 수도 있습니다.
+ 상태 시스템 작업을 추가하여 파이프라인을 업데이트합니다.

**Topics**
+ [사전 조건: 단순 파이프라인 생성 또는 선택](#tutorials-step-functions-prereq)
+ [1단계: 샘플 상태 시스템 생성](#tutorials-step-functions-sample)
+ [2단계: 파이프라인에 Step Functions 호출 작업 추가](#tutorials-step-functions-pipeline)

## 사전 조건: 단순 파이프라인 생성 또는 선택
<a name="tutorials-step-functions-prereq"></a>

이 자습서에서는 기존 파이프라인에 호출 작업을 추가합니다. [자습서: 간단한 파이프라인 생성(S3 버킷)](tutorials-simple-s3.md) 또는 [자습서: 간단한 파이프라인 생성(CodeCommit 리포지토리)](tutorials-simple-codecommit.md)에서 생성한 파이프라인을 사용할 수 있습니다.

소스 작업과 최소한 2-스테이지 구조의 기존 파이프라인을 사용하지만 이 예제에서는 소스 아티팩트를 사용하지 않습니다.

**참고**  
파이프라인에서 사용하는 서비스 역할을 이 작업을 실행하는 데 필요한 추가 권한으로 업데이트해야 할 수 있습니다. 이렇게 하려면 AWS Identity and Access Management (IAM) 콘솔을 열고 역할을 찾은 다음 역할 정책에 권한을 추가합니다. 자세한 내용은 [CodePipeline 서비스 역할에 권한 추가](how-to-custom-role.md#how-to-update-role-new-services) 단원을 참조하십시오.

## 1단계: 샘플 상태 시스템 생성
<a name="tutorials-step-functions-sample"></a>

Step Functions 콘솔에서 `HelloWorld` 샘플 템플릿을 사용하여 상태 시스템을 생성합니다. 지침은 *AWS Step Functions 개발자 가이드*의 [상태 머신 생성](https://docs.aws.amazon.com/step-functions/latest/dg/getting-started.html#create-state-machine)을 참조하세요.

## 2단계: 파이프라인에 Step Functions 호출 작업 추가
<a name="tutorials-step-functions-pipeline"></a>

다음과 같이 파이프라인에 Step Functions 호출 작업을 추가합니다.

1. 에 로그인 AWS Management Console 하고 [http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) CodePipeline 콘솔을 엽니다.

    AWS 계정과 연결된 모든 파이프라인의 이름이 표시됩니다.

1. [**Name**]에서 편집할 파이프라인의 이름을 선택합니다. 이렇게 하면 파이프라인 각 단계의 각 작업 상태를 포함하여 파이프라인의 세부 정보 보기가 열립니다.

1. 파이프라인 세부 정보 페이지에서 [**Edit**]를 선택합니다.

1. 단순 파이프라인의 두 번째 스테이지에서 **스테이지 편집**을 선택합니다. **삭제**를 선택합니다. 그러면 더 이상 필요하지 않으므로 두 번째 스테이지가 삭제됩니다.

1. 다이어그램의 하단에서 **\$1 단계 추가**를 선택합니다.

1. **스테이지 이름**에서 스테이지 이름(예: **Invoke**)을 입력한 다음 **스테이지 추가**를 선택합니다.

1. **\$1 Add action group(작업 그룹 추가)**을 선택합니다.

1. **작업 이름**에 이름(예: **Invoke**)을 입력합니다.

1. **작업 공급자**에서 **AWS Step Functions**를 선택합니다. **리전**이 파이프라인 리전으로 기본 설정되도록 합니다.

1. **입력 아티팩트**에서 `SourceArtifact`를 선택합니다.

1. **상태 시스템 ARN**에서 이전에 생성한 상태 시스템의 Amazon 리소스 이름(ARN)을 선택합니다.

1. (선택 사항) **실행 이름 접두사**에 상태 시스템 실행 ID에 추가할 접두사를 입력합니다.

1. **입력 유형**에서 **리터럴**을 선택합니다.

1. **입력**에 `HelloWorld` 샘플 상태 시스템이 예상하는 입력 JSON을 입력합니다.
**참고**  
상태 시스템 실행에 대한 입력은 CodePipeline에서 작업에 대한 입력 아티팩트를 설명하는 데 사용되는 용어와 다릅니다.

   이 예제에서는 다음 JSON을 입력합니다.

   ```
   {"IsHelloWorldExample": true}
   ```

1. **완료**를 선택합니다.

1. 편집 중인 스테이지에서 **완료**를 선택합니다. AWS CodePipeline 창에서 **저장**을 선택한 다음 경고 메시지에서 **저장**을 선택합니다.

1. 변경 사항을 제출하고 파이프라인 실행을 시작하려면 **변경 사항 배포**를 선택한 다음 **릴리스**를 선택합니다.

1. 완료된 파이프라인에서 호출 작업의 **AWS Step Functions**를 선택합니다. AWS Step Functions 콘솔에서 상태 시스템 실행 ID를 확인합니다. ID에는 상태 시스템 이름인 `HelloWorld`와 상태 시스템 실행 ID가 접두사 `my-prefix`와 함께 표시됩니다.

   ```
   arn:aws:states:us-west-2:account-ID:execution:HelloWorld:my-prefix-0d9a0900-3609-4ebc-925e-83d9618fcca1
   ```

# 자습서: AWS AppConfig를 배포 공급자로 사용하는 파이프라인 생성
<a name="tutorials-AppConfig"></a>

이 자습서에서는 AWS AppConfig를 배포 단계의 배포 작업 공급자로 사용하여 구성 파일을 지속적으로 전달하는 파이프라인을 구성합니다.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

**Topics**
+ [사전 조건](#tutorials-AppConfig-prereq)
+ [1단계: AWS AppConfig 리소스 생성](#tutorials-AppConfig-application)
+ [2단계: S3 소스 버킷에 파일 업로드](#tutorials-AppConfig-bucket)
+ [3단계: 파이프라인 생성](#tutorials-AppConfig-pipeline)
+ [4단계: 모든 소스 파일을 변경하고 배포 확인](#tutorials-AppConfig-verify)

## 사전 조건
<a name="tutorials-AppConfig-prereq"></a>

시작하기 전에 다음을 완료해야 합니다.
+ 이 예제에서는 파이프라인에 S3 소스를 사용합니다. 버전 관리가 활성화된 Amazon S3 버킷을 생성하거나 사용합니다. [1단계: 애플리케이션에 대한 S3 소스 버킷 생성](tutorials-simple-s3.md#s3-create-s3-bucket)의 지침을 따라 S3 버킷을 생성합니다.

## 1단계: AWS AppConfig 리소스 생성
<a name="tutorials-AppConfig-application"></a>

이 섹션에서는 다음 리소스를 생성합니다.
+ *애플리케이션* in AWS AppConfig는 고객에게 기능을 제공하는 논리적 코드 단위입니다.
+ 환경 in AWS AppConfig는 베타 또는 프로덕션 *환경*의 애플리케이션과 같은 AppConfig 대상의 논리적 배포 그룹입니다.
+ 구성 프로필은 애플리케이션의 동작에 영향을 미치는 설정의 모음입니다.** 구성 프로파일을 사용하면 AWS AppConfig가 저장된 위치의 구성에 액세스할 수 있습니다.
+ (선택 사항) AWS AppConfig의 배포 전략은 배포 중 특정 시점에 새로 배포된 구성을 수신해야 하는 클라이언트의 비율과 같은 구성 배포의 동작을 정의합니다.**

**애플리케이션, 환경, 구성 프로필 및 배포 전략을 생성하려면**

1.  AWS Management Console에 로그인합니다.

1.  AWS AppConfig에서 리소스를 생성하려면 다음 주제의 단계를 사용합니다.
   + [애플리케이션 생성](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-application.html).
   + [환경을 생성](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-environment.html)합니다.
   + [AWS CodePipeline 구성 프로파일을 생성합니다](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-configuration-and-profile.html).
   + (선택 사항) [사전 정의된 배포 전략을 선택 또는 직접 생성](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-deployment-strategy.html).

## 2단계: S3 소스 버킷에 파일 업로드
<a name="tutorials-AppConfig-bucket"></a>

이 섹션에서 구성 파일을 생성합니다. 그런 다음 소스 파일을 압축하여 파이프라인이 소스 단계에 대해 사용하는 버킷으로 푸시합니다.

**구성 파일을 생성하려면**

1. 각 리전의 각 구성에 대한 `configuration.json` 파일을 생성합니다. 다음 콘텐츠를 포함합니다.

   ```
   Hello World!
   ```

1. 다음 단계를 사용하여 구성 파일을 압축하고 업로드하세요.

**소스 파일을 압축하고 업로드하려면**

1. 파일이 포함된 .zip 파일을 생성하고 .zip 파일의 이름을 `configuration-files.zip`으로 지정합니다. 예를 들어 .zip 파일은 다음과 같은 구조를 사용할 수 있습니다.

   ```
   .
   └── appconfig-configurations
       └── MyConfigurations
           ├── us-east-1
           │   └── configuration.json
           └── us-west-2
               └── configuration.json
   ```

1. 버킷의 Amazon S3 콘솔에서 업로드를 선택하고 지침을 따라 .zip 파일을 **업로드**합니다.

## 3단계: 파이프라인 생성
<a name="tutorials-AppConfig-pipeline"></a>

이 단원에서는 다음 작업을 통해 파이프라인을 생성합니다.
+ 소스 아티팩트가 구성용 파일인 Amazon S3 작업이 있는 소스 단계.
+ AppConfig 배포 작업이 적용된 배포 단계.

**마법사를 사용하여 파이프라인을 생성하려면**

1. 에 로그인 AWS Management Console 하고 [http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) CodePipeline 콘솔을 엽니다.

1. [**Welcome**] 페이지, [**Getting started**] 페이지 또는 [**Pipelines**] 페이지에서 **Create pipeline(파이프라인 생성)**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 **MyAppConfigPipeline**을 입력합니다.

1. CodePipeline은 특성과 가격이 다른 V1 및 V2 유형 파이프라인을 제공합니다. V2 유형은 콘솔에서 선택할 수 있는 유일한 유형입니다. 자세한 내용은 [파이프라인 유형](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)을 참조하세요. CodePipeline에 대한 요금 정보는 [요금](https://aws.amazon.com/codepipeline/pricing/)을 참조하세요.

1. **서비스 역할**에서 **새 서비스 역할**을 선택하여CodePipeline이 IAM에 서비스 역할을 생성하도록 허용합니다.

1. [**Advanced settings**]의 설정은 기본값 그대로 두고, [**Next**]를 선택합니다.

1. **3단계: 소스 스테이지 추가**의 **소스 공급자**에서 **Amazon S3**를 선택합니다. **버킷**에서 S3 소스 버킷의 이름을 선택합니다.

   **S3 객체 키**에 .zip 파일: `configuration-files.zip`의 이름을 입력합니다.

   **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가**에서 **빌드 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **6단계: 배포 단계 추가**에서:

   1. **배포 공급자**에서 **AWS AppConfig**를 선택합니다.

   1. **애플리케이션에서** AWS AppConfig에서 생성한 애플리케이션의 이름을 선택합니다. 필드에 애플리케이션의 ID가 표시됩니다.

   1. **환경에서** AWS AppConfig에서 생성한 환경의 이름을 선택합니다. 필드에 환경의 ID가 표시됩니다.

   1. **구성 프로필**에서 AWS AppConfig에서 생성한 구성 프로필의 이름을 선택합니다. 필드에 구성 프로필의 ID가 표시됩니다.

   1. **배포 전략**에서 배포 전략의 이름을 선택합니다. 이것은 AppConfig에서 만든 배포 전략이거나 AppConfig에서 미리 정의된 배포 전략 중에서 선택한 전략일 수 있습니다. 필드에는 배포 전략의 ID가 표시됩니다.

   1. **입력 아티팩트 구성 경로**에 파일 경로를 입력합니다. 입력 아티팩트 구성 경로가 S3 버킷 .zip 파일의 디렉터리 구조와 일치하는지 확인하세요. 이 예제에서는 파일 경로(`appconfig-configurations/MyConfigurations/us-west-2/configuration.json`)를 입력합니다.

   1. **다음**을 선택합니다.

1. **7단계: 검토**에서 정보를 검토한 다음 **파이프라인 생성을** 선택합니다.

## 4단계: 모든 소스 파일을 변경하고 배포 확인
<a name="tutorials-AppConfig-verify"></a>

소스 파일을 변경하고 변경 사항을 버킷에 업로드합니다. 이렇게 하면 파이프라인이 실행됩니다. 버전을 확인하여 구성을 사용할 수 있는지 확인하세요.

# 자습서: GitHub 파이프라인 소스와 함께 전체 복제 사용
<a name="tutorials-github-gitclone"></a>

CodePipeline에서 GitHub 소스 작업에 대한 전체 복제 옵션을 선택할 수 있습니다. 이 옵션을 사용하면 파이프라인 빌드 작업에서 Git 메타데이터에 대한 CodeBuild 명령을 실행할 수 있습니다.

**참고**  
여기에 설명된 전체 복제 옵션은 CodePipeline이 CodeBuild 명령에서만 사용할 수 있는 리포지토리 메타데이터를 복제할지 여부를 지정하는 것을 나타냅니다. CodeBuild 프로젝트에서 사용할 GitHub [ 사용자 액세스 토큰](https://docs.github.com/en/apps/creating-github-apps/authenticating-with-a-github-app/generating-a-user-access-token-for-a-github-app)을 사용하려면 여기의 단계에 따라 GitHub용 AWS 커넥터 앱을 설치한 다음 앱 설치 필드를 비워 둡니다. CodeConnections는 연결에 사용자 액세스 토큰을 사용합니다.



**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

이 자습서에서는 GitHub 리포지토리에 연결하는 파이프라인을 만들고, 소스 데이터에 대한 전체 복제 옵션을 사용하고, 리포지토리를 복제하고 리포지토리에 대한 Git 명령을 수행하는 CodeBuild 빌드를 실행합니다.

**참고**  
아시아 태평양(홍콩), 아프리카(케이프타운), 중동(바레인), 유럽(취리히) 또는 AWS GovCloud(미국 서부) 리전에서는이 기능을 사용할 수 없습니다. 사용 가능한 다른 작업을 참조하려면 [CodePipeline과 제품 및 서비스 통합](integrations.md)을 참조하세요. 유럽(밀라노) 리전에서 이 조치를 고려할 경우 [Bitbucket Cloud, GitHub, GitHub Enterprise Server, GitLab.com 및 GitLab 자체 관리형 작업용 CodeStarSourceConnection](action-reference-CodestarConnectionSource.md)의 참고 사항을 참조하세요.

**Topics**
+ [사전 조건](#tutorials-github-gitclone-prereq)
+ [1단계: README 파일 생성](#tutorials-github-gitclone-file)
+ [2단계: 파이프라인 및 빌드 프로젝트 생성](#tutorials-github-gitclone-pipeline)
+ [3단계: 연결을 사용하도록 CodeBuild 서비스 역할 정책 업데이트](#tutorials-github-gitclone-rolepolicy)
+ [4단계: 빌드 출력에서 리포지토리 명령 보기](#tutorials-github-gitclone-view)

## 사전 조건
<a name="tutorials-github-gitclone-prereq"></a>

시작하기 전에 다음을 수행해야 합니다.
+ GitHub 계정을 사용하여 GitHub 리포지토리를 만듭니다.
+ GitHub 자격 증명을 준비합니다. AWS Management Console 를 사용하여 연결을 설정하면 GitHub 자격 증명으로 로그인하라는 메시지가 표시됩니다.

## 1단계: README 파일 생성
<a name="tutorials-github-gitclone-file"></a>

GitHub 리포지토리를 만든 후 다음 단계를 사용하여 README 파일을 추가하세요.

1. GitHub 리포지토리에 로그인하고 리포지토리를 선택합니다.

1. 새 파일을 생성하려면 **파일 추가 > 새 파일 생성**을 선택합니다. 파일 이름을 `README.md`. 파일로 지정하고 다음 텍스트를 추가합니다.

   ```
   This is a GitHub repository!
   ```

1. **변경 사항 커밋**을 선택합니다.

   `README.md` 파일이 리포지토리의 루트 수준에 있는지 확인합니다.

## 2단계: 파이프라인 및 빌드 프로젝트 생성
<a name="tutorials-github-gitclone-pipeline"></a>

이 단원에서는 다음 작업을 통해 파이프라인을 생성합니다.
+ GitHub 리포지토리 및 작업에 대한 연결이 있는 소스 단계입니다.
+ 빌드 작업이 있는 AWS CodeBuild 빌드 단계입니다.

**마법사를 사용하여 파이프라인을 생성하려면**

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔에 로그인합니다.

1. **Welcome(시작)** 페이지, **시작하기** 페이지 또는 **Pipelines(파이프라인)** 페이지에서 **파이프라인 생성**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 **MyGitHubPipeline**을 입력합니다.

1. **파이프라인 유형**에서 이 자습서의 목적에 맞는 **V1**을 선택합니다. **V2**를 선택할 수도 있지만 파이프라인 유형별 특성과 가격이 다르다는 점에 유의하십시오. 자세한 내용은 [파이프라인 유형](pipeline-types.md) 단원을 참조하십시오.

1. **Service role(서비스 역할)**에서 **New service role(새 서비스 역할)**을 선택합니다.
**참고**  
역할을 생성하지 않고 기존 CodePipeline 서비스 역할을 사용할 경우 서비스 역할 정책에 대한 `codestar-connections:UseConnection` IAM 권한을 추가해야 합니다. CodePipeline 서비스 역할에 대한 지침은 [CodePipeline 서비스 역할에 권한 추가](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)를 참조하세요.

1. **고급 설정**에서 기본값을 그대로 둡니다. [**아티팩트 스토어(Artifact store)**]에서 [**기본 위치(Default location)**]를 선택하여 파이프라인에 대해 선택한 리전의 파이프라인에 대해 기본값으로 지정된 Amazon S3 아티팩트 버킷과 같은 기본 아티팩트 스토어를 사용합니다.
**참고**  
이는 소스 코드에 대한 소스 버킷이 아닙니다. 이 파이프라인은 아티팩트 스토어입니다. S3 버킷과 같은 개별 아티팩트 스토어는 각 파이프라인에 필요합니다.

   **다음**을 선택합니다.

1. **3단계: 소스 스테이지 추가** 페이지에서 소스 스테이지를 추가합니다.

   1. **소스 공급자**에서 **GitHub(GitHub 앱 사용)**를 선택합니다.

   1. **연결**에서 기존 연결을 선택하거나 새로 생성합니다. GitHub 소스 작업에 대한 연결을 만들거나 관리하려면 [GitHub 연결](connections-github.md)을 참조하세요.

      특정 공급자에 대한 모든 연결에 대해 하나의 앱을 설치합니다. AWS Connector for GitHub 앱을 이미 설치한 경우 해당 앱을 선택하고이 단계를 건너뜁니다.
**참고**  
[ 사용자 액세스 토큰](https://docs.github.com/en/apps/creating-github-apps/authenticating-with-a-github-app/generating-a-user-access-token-for-a-github-app)을 생성하려면 AWS Connector for GitHub 앱을 이미 설치했는지 확인한 다음 앱 설치 필드를 비워 둡니다. CodeConnections는 연결에 사용자 액세스 토큰을 사용합니다. 자세한 내용은 [CodeBuild의 소스 공급자 액세스](https://docs.aws.amazon.com/codebuild/latest/userguide/access-tokens.html)를 참조하세요.

   1. **리포지토리 이름**에서 GitHub 리포지토리의 이름을 선택합니다.

   1. **브랜치 이름**에서 사용할 리포지토리 브랜치를 선택합니다.

   1. **소스 코드 변경 시 파이프라인 시작** 옵션을 선택합니다.

   1. **출력 아티팩트 형식**에서 **전체 복제**를 선택하여 소스 리포지토리의 Git 복제 옵션을 활성화합니다. CodeBuild에서 제공하는 작업만 Git 복제 옵션을 사용할 수 있습니다. 이 자습서에서는 CodeBuild 프로젝트 서비스 역할이 이 옵션을 사용하도록 권한을 업데이트하는 데 [3단계: 연결을 사용하도록 CodeBuild 서비스 역할 정책 업데이트](#tutorials-github-gitclone-rolepolicy)을 사용합니다.

   **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가**에서 빌드 스테이지를 추가합니다.

   1. **빌드 공급자**에서 **AWS CodeBuild**를 선택합니다. **리전**이 파이프라인 리전으로 기본 설정되도록 합니다.

   1. **프로젝트 생성**을 선택합니다.

   1. **프로젝트 이름**에 이 빌드 프로젝트의 이름을 입력합니다.

   1. **환경 이미지**에서 **이미지 관리**를 선택합니다. [**Operating system**]에서 [**Ubuntu**]를 선택합니다.

   1. **실행 시간**에서 **표준**을 선택합니다. **이미지**에서 **aws/codebuild/standard:5.0**을 선택합니다.

   1. **서비스 역할**에서 **New service role(새 서비스 역할)**을 선택합니다.
**참고**  
CodeBuild 서비스 역할의 이름을 기록해 둡니다. 이 자습서의 마지막 단계를 수행하려면 역할 이름이 필요합니다.

   1. [**Buildspec**]의 [**빌드 사양(Build specifications)**]에서 [**빌드 명령 삽입(Insert build commands)**]을 선택합니다. **편집기로 전환**을 선택하고 **빌드 명령**에 다음을 붙여 넣습니다.
**참고**  
빌드 사양의 `env` 섹션에서 이 예제와 같이 git 명령의 보안 인증 도우미가 활성화되어 있는지 확인하세요.

      ```
      version: 0.2
      
      env:
        git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
            # name: version
          #commands:
            # - command
            # - command
        pre_build:
          commands:
            - ls -lt
            - cat README.md
        build:
          commands:
            - git log | head -100
            - git status
            - ls
            - git archive --format=zip HEAD > application.zip
        #post_build:
          #commands:
            # - command
            # - command
      artifacts:
        files:
          - application.zip
          # - location
        #name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. **Continue to CodePipeline(CodePipeline으로 계속)**을 선택합니다. 그러면 CodePipeline 콘솔로 돌아가고 구성을 위해 빌드 명령을 사용하는 CodeBuild 프로젝트가 생성됩니다. 빌드 프로젝트는 서비스 역할을 사용하여 AWS 서비스 권한을 관리합니다. 이 단계는 몇 분이 걸릴 수 있습니다.

   1. **다음**을 선택합니다.

1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **6단계: 배포 단계 추가** 페이지에서 **배포 단계 건너뛰기를** 선택한 다음 다시 **건너뛰기를** 선택하여 경고 메시지를 수락합니다. **다음**을 선택합니다.

1. **7단계: 검토**에서 **파이프라인 생성을** 선택합니다.

## 3단계: 연결을 사용하도록 CodeBuild 서비스 역할 정책 업데이트
<a name="tutorials-github-gitclone-rolepolicy"></a>

CodeBuild 서비스 역할을 연결 사용 권한으로 업데이트해야 하므로 초기 파이프라인 실행이 실패합니다. 서비스 역할 정책에 `codestar-connections:UseConnection` IAM 권한을 추가합니다. IAM 콘솔에서 정책을 업데이트하는 방법에 대한 지침은 [Bitbucket, GitHub, GitHub Enterprise Server 또는 GitLab.com 연결을 위한 CodeBuild GitClone 권한 추가](troubleshooting.md#codebuild-role-connections)을 참조하세요.

## 4단계: 빌드 출력에서 리포지토리 명령 보기
<a name="tutorials-github-gitclone-view"></a>

1. 서비스 역할이 성공적으로 업데이트되면 실패한 CodeBuild 단계에서 **재시도**를 선택합니다.

1. 파이프라인이 성공적으로 실행되면 성공적으로 완료된 빌드 단계에서 **세부 정보 보기**를 선택합니다.

   세부 정보 페이지에서 **로그** 탭을 선택합니다. CodeBuild 빌드 출력을 확인합니다. 명령은 입력된 변수의 값을 출력합니다.

   명령은 `README.md` 파일 콘텐츠를 출력하고, 디렉터리의 파일을 나열하고, 리포지토리를 복제하고, 로그를 보고, 리포지토리를 ZIP 파일로 보관합니다.

# 자습서: CodeCommit 파이프라인 소스와 함께 전체 복제 사용
<a name="tutorials-codecommit-gitclone"></a>

CodePipeline에서 CodeCommit 소스 작업에 대한 전체 복제 옵션을 선택할 수 있습니다. 이 옵션을 사용하면 CodeBuild가 파이프라인 빌드 작업에서 Git 메타데이터에 액세스할 수 있습니다.

이 자습서에서는 CodeCommit 리포지토리에 액세스하는 파이프라인을 만들고, 소스 데이터에 대한 전체 복제 옵션을 사용하고, 리포지토리를 복제하고 리포지토리에 대한 Git 명령을 수행하는 CodeBuild 빌드를 실행합니다.

**참고**  
CodeBuild 작업은 Git 복제 옵션과 함께 사용할 수 있는 Git 메타데이터 사용을 지원하는 유일한 다운스트림 작업입니다. 또한 파이프라인에 계정 간 작업이 포함될 수 있지만 전체 복제 옵션이 성공하려면 CodeCommit 작업과 CodeBuild 작업이 동일한 계정에 있어야 합니다.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

**Topics**
+ [사전 조건](#tutorials-codecommit-gitclone-prereq)
+ [1단계: README 파일 생성](#tutorials-codecommit-gitclone-file)
+ [2단계: 파이프라인 및 빌드 프로젝트 생성](#tutorials-codecommit-gitclone-pipeline)
+ [3단계: 리포지토리를 복제하도록 CodeBuild 서비스 역할 정책 업데이트](#tutorials-codecommit-gitclone-rolepolicy)
+ [4단계: 빌드 출력에서 리포지토리 명령 보기](#tutorials-codecommit-gitclone-view)

## 사전 조건
<a name="tutorials-codecommit-gitclone-prereq"></a>

시작하기 전에 파이프라인과 동일한 AWS 계정 및 리전에 CodeCommit 리포지토리를 생성해야 합니다.

## 1단계: README 파일 생성
<a name="tutorials-codecommit-gitclone-file"></a>

다음 단계를 사용하여 소스 리포지토리에 README 파일을 추가합니다. README 파일은 CodeBuild 다운스트림 작업에서 읽을 수 있는 예제 소스 파일을 제공합니다.

**README 파일을 추가하려면**

1. 리포지토리에 로그인하고 리포지토리를 선택합니다.

1. 새 파일을 생성하려면 **파일 추가 > 파일 생성**을 선택합니다. 파일 이름을 `README.md`. 파일로 지정하고 다음 텍스트를 추가합니다.

   ```
   This is a CodeCommit repository!
   ```

1. **변경 사항 커밋**을 선택합니다.

   `README.md` 파일이 리포지토리의 루트 수준에 있는지 확인합니다.

## 2단계: 파이프라인 및 빌드 프로젝트 생성
<a name="tutorials-codecommit-gitclone-pipeline"></a>

이 단원에서는 다음 작업을 통해 파이프라인을 생성합니다.
+ CodeCommit 소스 작업이 있는 소스 단계입니다.
+ 빌드 작업이 있는 AWS CodeBuild 빌드 단계입니다.

**마법사를 사용하여 파이프라인을 생성하려면**

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔에 로그인합니다.

1. **Welcome(시작)** 페이지, **시작하기** 페이지 또는 **Pipelines(파이프라인)** 페이지에서 **파이프라인 생성**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 **MyCodeCommitPipeline**을 입력합니다.

1. CodePipeline은 특성과 가격이 다른 V1 및 V2 유형 파이프라인을 제공합니다. V2 유형은 콘솔에서 선택할 수 있는 유일한 유형입니다. 자세한 내용은 [파이프라인 유형](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)을 참조하세요. CodePipeline에 대한 요금 정보는 [요금](https://aws.amazon.com/codepipeline/pricing/)을 참조하세요.

1. **서비스 역할**에서 다음 중 하나를 수행합니다.
   + **Existing service role(기존 서비스 역할)**을 선택합니다.
   + 기존 CodePipeline 서비스 역할을 선택합니다. 이 역할에는 서비스 역할 정책에 대한 `codecommit:GetRepository` IAM 권한이 있어야 합니다. [CodePipeline 서비스 역할에 권한 추가](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)를 참조하세요.

1. **고급 설정**에서 기본값을 그대로 둡니다. **다음**을 선택합니다.

1. **3단계: 소스 스테이지 추가** 페이지에서 다음을 수행합니다.

   1. **소스 공급자**에서 **CodeCommit**을 선택합니다.

   1. **리포지토리 이름**에서 리포지토리의 이름을 선택합니다.

   1. **브랜치 이름**에서 브랜치 이름을 선택합니다.

   1. **소스 코드 변경 시 파이프라인 시작** 옵션을 선택합니다.

   1. **출력 아티팩트 형식**에서 **전체 복제**를 선택하여 소스 리포지토리의 Git 복제 옵션을 활성화합니다. CodeBuild에서 제공하는 작업만 Git 복제 옵션을 사용할 수 있습니다.

   **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가**에서 다음을 수행하세요.

   1. **빌드 공급자**에서 **AWS CodeBuild**를 선택합니다. **리전**이 파이프라인 리전으로 기본 설정되도록 합니다.

   1. **프로젝트 생성**을 선택합니다.

   1. **프로젝트 이름**에 이 빌드 프로젝트의 이름을 입력합니다.

   1. **환경 이미지**에서 **이미지 관리**를 선택합니다. [**Operating system**]에서 [**Ubuntu**]를 선택합니다.

   1. **실행 시간**에서 **표준**을 선택합니다. **이미지**에서 **aws/codebuild/standard:5.0**을 선택합니다.

   1. **서비스 역할**에서 **New service role(새 서비스 역할)**을 선택합니다.
**참고**  
CodeBuild 서비스 역할의 이름을 기록해 둡니다. 이 자습서의 마지막 단계를 수행하려면 역할 이름이 필요합니다.

   1. [**Buildspec**]의 [**빌드 사양(Build specifications)**]에서 [**빌드 명령 삽입(Insert build commands)**]을 선택합니다. **편집기로 전환**을 선택한 다음 **빌드 명령**에 다음 코드를 붙여 넣습니다.

      ```
      version: 0.2
      
      env:
        git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
            # name: version
          #commands:
            # - command
            # - command
        pre_build:
          commands:
            - ls -lt
            - cat README.md
        build:
          commands:
            - git log | head -100
            - git status
            - ls
            - git describe --all
        #post_build:
          #commands:
            # - command
            # - command
      #artifacts:
        #files:
          # - location
        #name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. **Continue to CodePipeline(CodePipeline으로 계속)**을 선택합니다. 그러면 CodePipeline 콘솔로 돌아가고 구성을 위해 빌드 명령을 사용하는 CodeBuild 프로젝트가 생성됩니다. 빌드 프로젝트가 서비스 역할을 사용하여 AWS 서비스 권한을 관리합니다. 이 단계는 몇 분이 걸릴 수 있습니다.

   1. **다음**을 선택합니다.

1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **6단계: 배포 단계 추가** 페이지에서 **배포 단계 건너뛰기를** 선택한 다음 다시 **건너뛰기를** 선택하여 경고 메시지를 수락합니다. **다음**을 선택합니다.

1. **7단계: 검토**에서 **파이프라인 생성을** 선택합니다.

## 3단계: 리포지토리를 복제하도록 CodeBuild 서비스 역할 정책 업데이트
<a name="tutorials-codecommit-gitclone-rolepolicy"></a>

리포지토리에서 가져올 수 있는 권한으로 CodeBuild 서비스 역할을 업데이트해야 하므로 초기 파이프라인 실행이 실패합니다.

서비스 역할 정책에 `codecommit:GitPull` IAM 권한을 추가합니다. IAM 콘솔에서 정책을 업데이트하는 방법에 대한 지침은 [CodeCommit 소스 작업에 대한 CodeBuild GitClone 권한 추가](troubleshooting.md#codebuild-role-codecommitclone)을 참조하세요.

## 4단계: 빌드 출력에서 리포지토리 명령 보기
<a name="tutorials-codecommit-gitclone-view"></a>

**빌드 출력을 보려면**

1. 서비스 역할이 성공적으로 업데이트되면 실패한 CodeBuild 단계에서 **재시도**를 선택합니다.

1. 파이프라인이 성공적으로 실행되면 성공적으로 완료된 빌드 단계에서 **세부 정보 보기**를 선택합니다.

   세부 정보 페이지에서 **로그** 탭을 선택합니다. CodeBuild 빌드 출력을 확인합니다. 명령은 입력된 변수의 값을 출력합니다.

   명령은 `README.md` 파일 콘텐츠를 출력하고, 디렉터리의 파일을 나열하고, 리포지토리를 복제하고, 로그를 보고, `git describe --all`을 실행합니다.

# 자습서: AWS CloudFormation StackSets 배포 작업을 사용하여 파이프라인 생성
<a name="tutorials-stackset-deployment"></a>

이 자습서에서는 AWS CodePipeline 콘솔을 사용하여 스택 세트를 생성하고 스택 인스턴스를 생성하기 위한 배포 작업이 포함된 파이프라인을 생성합니다. 파이프라인이 실행되면 템플릿은 스택 세트를 생성하고 스택 세트가 배포된 인스턴스를 생성 및 업데이트합니다.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

스택 세트에 대한 권한을 관리하는 방법에는 자체 관리형 및 AWS관리형 IAM 역할의 두 가지가 있습니다. 이 자습서에서는 자체 관리형 권한의 예를 제공합니다.

CodePipeline에서 Stacksets를 가장 효과적으로 사용하려면 CloudFormation StackSets의 개념과 작동 방식을 명확하게 이해해야 합니다.AWS CloudFormation 사용 설명서의 [StackSets 개념](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-concepts.html)을 참조하세요.**

**Topics**
+ [사전 조건](#tutorials-stackset-deployment-prereq)
+ [1단계: 샘플 AWS CloudFormation 템플릿 및 파라미터 파일 업로드](#tutorials-stackset-deployment-upload)
+ [2단계: 파이프라인 생성](#tutorials-stackset-action-pipeline)
+ [3단계: 초기 배포 보기](#tutorials-stackset-action-initial)
+ [4단계: CloudFormationStackInstances 작업 추가](#tutorials-stacksets-instances)
+ [5단계: 배포를 위한 스택 세트 리소스 보기](#tutorials-stacksets-view)
+ [6단계: 스택 세트 업데이트](#tutorials-stacksets-update)

## 사전 조건
<a name="tutorials-stackset-deployment-prereq"></a>

스택 세트 작업의 경우 관리자 계정과 대상 계정이라는 두 개의 다른 계정을 사용합니다. 관리자 계정에서 스택 세트를 생성합니다. 대상 계정에서 스택 세트에 속하는 개별 스택을 생성합니다.

**관리자 계정으로 관리자 역할을 만들려면**
+ [스택 세트 작업에 대한 기본 권한 설정](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-self-managed.html#stacksets-prereqs-accountsetup)의 지침을 따릅니다. 역할 이름은 **`AWSCloudFormationStackSetAdministrationRole`**이어야 합니다.

**대상 계정에서 서비스 역할을 생성하려면**
+ 관리자 계정을 신뢰하는 대상 계정에서 서비스 역할을 생성합니다. [스택 세트 작업에 대한 기본 권한 설정](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-self-managed.html#stacksets-prereqs-accountsetup)의 지침을 따릅니다. 역할 이름은 **`AWSCloudFormationStackSetExecutionRole`**이어야 합니다.

## 1단계: 샘플 AWS CloudFormation 템플릿 및 파라미터 파일 업로드
<a name="tutorials-stackset-deployment-upload"></a>

스택 세트 템플릿과 파라미터 파일에 대한 소스 버킷을 생성합니다. 샘플 AWS CloudFormation 템플릿 파일을 다운로드하고 파라미터 파일을 설정한 다음 S3 소스 버킷에 업로드하기 전에 파일을 압축합니다.

**참고**  
소스 파일이 템플릿뿐이더라도 S3 소스 버킷에 업로드하기 전에 소스 파일을 압축해야 합니다.



**S3 소스 버킷을 생성하려면**

1. 에 로그인 AWS Management Console 하고 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) Amazon S3 콘솔을 엽니다.

1. **버킷 생성**을 선택합니다.

1. **버킷 이름**에 버킷 이름을 입력합니다.

   **리전**에서 파이프라인을 생성하려는 리전을 선택합니다. **버킷 생성**을 선택합니다.

1. 버킷이 생성되면 성공적으로 수행했다는 배너가 표시됩니다. [**Go to bucket details**]를 선택합니다.

1. [**Properties**] 탭에서 [**Versioning**]을 선택합니다. [**Enable versioning**]을 선택한 다음 [**Save**]를 선택합니다.

**AWS CloudFormation 템플릿 파일을 생성하려면**

1. 스택 세트에 대한 CloudTrail 구성을 생성하기 위한 샘플 템플릿 파일([https://s3.amazonaws.com/cloudformation-stackset-sample-templates-us-east-1/EnableAWSCloudtrail.yml](https://s3.amazonaws.com/cloudformation-stackset-sample-templates-us-east-1/EnableAWSCloudtrail.yml))을 다운로드하세요.

1. 파일을 `template.yml`(으)로 저장합니다.

**parameters.txt 파일을 생성하려면**

1. 배포용 파라미터가 포함된 파일을 생성합니다. 파라미터는 런타임 시 스택에서 업데이트하려는 값입니다. 다음 샘플 파일은 스택 세트의 템플릿 파라미터를 업데이트하여 로깅 검증 및 글로벌 이벤트를 활성화합니다.

   ```
   [
     {
       "ParameterKey": "EnableLogFileValidation",
       "ParameterValue": "true"
     }, 
     {
       "ParameterKey": "IncludeGlobalEvents",
       "ParameterValue": "true"
     }
   ]
   ```

1. 파일을 `parameters.txt`(으)로 저장합니다.

**accounts.txt 파일을 생성하려면**

1. 다음 샘플 파일과 같이 인스턴스를 만들려는 계정이 포함된 파일을 생성합니다.

   ```
   [
       "111111222222","333333444444"
   ]
   ```

1. 파일을 `accounts.txt`(으)로 저장합니다.

**소스 파일을 압축하고 업로드하려면**

1. 파일을 하나의 ZIP 파일로 결합합니다. 파일은 ZIP 파일에 다음과 같이 나타납니다.

   ```
   template.yml
   parameters.txt
   accounts.txt
   ```

1. ZIP 파일을 S3 버킷에 업로드합니다. 이 파일은 **파이프라인 생성** 마법사가 CodePipeline에서 배포 작업을 위해 생성한 소스 아티팩트입니다.

## 2단계: 파이프라인 생성
<a name="tutorials-stackset-action-pipeline"></a>

이 단원에서는 다음 작업을 통해 파이프라인을 생성합니다.
+ 소스 아티팩트가 템플릿 파일 및 모든 지원 소스 파일인 S3 작업이 있는 소스 단계입니다.
+  CloudFormation 스택 세트를 생성하는 스택 세트 배포 작업이 있는 배포 단계입니다.
+ 대상 계정 내에 CloudFormation 스택과 인스턴스를 생성하는 스택 인스턴스 배포 작업이 있는 배포 단계입니다.

**CloudFormationStackSet 작업을 사용하여 파이프라인을 만들려면**

1. 에 로그인 AWS Management Console 하고 [http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) CodePipeline 콘솔을 엽니다.

1. **Welcome(시작)** 페이지, **시작하기** 페이지 또는 **Pipelines(파이프라인)** 페이지에서 **파이프라인 생성**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 **MyStackSetsPipeline**을 입력합니다.

1. **파이프라인 유형**에서 이 자습서의 목적에 맞는 **V1**을 선택합니다. **V2**를 선택할 수도 있지만 파이프라인 유형별 특성과 가격이 다르다는 점에 유의하십시오. 자세한 내용은 [파이프라인 유형](pipeline-types.md) 단원을 참조하십시오.

1. **서비스 역할**에서 **새 서비스 역할**을 선택하여CodePipeline이 IAM에 서비스 역할을 생성하도록 허용합니다.

1. **아티팩트 스토어**에서는 기본값을 그대로 유지합니다.
**참고**  
이는 소스 코드에 대한 소스 버킷이 아닙니다. 이 파이프라인은 아티팩트 스토어입니다. S3 버킷과 같은 개별 아티팩트 스토어는 각 파이프라인에 필요합니다. 파이프라인을 생성하거나 편집할 때는 파이프라인 리전에 아티팩트 버킷이 있고 작업을 실행하는 AWS 리전당 하나의 아티팩트 버킷이 있어야 합니다.  
자세한 내용은 [입력 및 출력 아티팩트](welcome-introducing-artifacts.md) 및 [CodePipeline 파이프라인 구조 참조](reference-pipeline-structure.md) 섹션을 참조하세요.

   **다음**을 선택합니다.

1. **3단계: 소스 스테이지 추가** 페이지의 **소스 공급자**에서 **Amazon S3**를 선택합니다.

1. **버킷**에 이 자습서를 위해 생성한 S3 소스 버킷(예: `BucketName`)을 입력합니다. **S3 객체 키**에 ZIP 파일의 파일 경로와 파일 이름(예: `MyFiles.zip`)을 입력합니다.

1. **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가**에서 **빌드 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **6단계: 배포 단계 추가**에서:

   1. **배포 공급자**에서 **AWS CloudFormation 스택 세트**를 선택합니다.

   1. **스택 세트 이름**에 스택 세트의 이름을 입력합니다. 템플릿이 생성하는 스택 세트의 이름입니다.
**참고**  
스택 세트 이름을 적어 둡니다. 파이프라인에 두 번째 StackSets 배포 작업을 추가할 때 사용합니다.

   1. **템플릿 경로**에 템플릿 파일을 업로드한 아티팩트 이름과 파일 경로를 입력합니다. 예를 들어, 기본 소스 아티팩트 이름 `SourceArtifact`를 사용하여 다음을 입력합니다.

      ```
      SourceArtifact::template.yml
      ```

   1. **배포 대상**에서 계정 파일을 업로드한 아티팩트 이름과 파일 경로를 입력합니다. 예를 들어, 기본 소스 아티팩트 이름 `SourceArtifact`를 사용하여 다음을 입력합니다.

      ```
      SourceArtifact::accounts.txt
      ```

   1. **배포 대상 AWS 리전**에와 같이 초기 스택 인스턴스를 배포할 리전 하나를 입력합니다`us-east-1`.

   1. **배포 옵션**을 확장합니다. **파라미터**에 파라미터 파일을 업로드한 아티팩트 이름과 파일 경로를 입력합니다. 예를 들어, 기본 소스 아티팩트 이름 `SourceArtifact`를 사용하여 다음을 입력합니다.

      ```
      SourceArtifact::parameters.txt
      ```

      파라미터를 파일 경로가 아닌 리터럴 입력으로 입력하려면 다음을 입력합니다.

      ```
      ParameterKey=EnableLogFileValidation,ParameterValue=true
      ParameterKey=IncludeGlobalEvents,ParameterValue=true
      ```

   1. **기능**에서 CAPABILITY\$1IAM 및 CAPABILITY\$1NAMED\$1IAM을 선택합니다.

   1. **권한 모델**에서 SELF\$1MANAGED를 선택합니다.

   1. **내결함성 비율**에 `20`을 입력합니다.

   1. **최대 동시 비율**에 `25`를 입력합니다.

   1. **다음**을 선택합니다.

   1. **7단계: 검토** 페이지에서 **파이프라인 생성**을 선택합니다. 파이프라인이 표시됩니다.

   1. 파이프라인이 실행되도록 허용합니다.

## 3단계: 초기 배포 보기
<a name="tutorials-stackset-action-initial"></a>

초기 배포에 대한 리소스와 상태를 확인합니다. 배포에서 스택 세트가 성공적으로 생성되었는지 확인한 후 **배포** 단계에 두 번째 작업을 추가할 수 있습니다.

**리소스를 보려면**

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔을 엽니다.

1. **파이프라인**에서 파이프라인을 선택하고 **보기**를 선택합니다. 다이어그램은 파이프라인 소스 및 배포 단계를 보여줍니다.

1. 파이프라인의 **CloudFormationStackSet** CloudFormation 작업에서 작업을 선택합니다. 스택 세트의 템플릿, 리소스 및 이벤트는 CloudFormation 콘솔에 표시됩니다.

1. 왼쪽 탐색 창에서 **StackSets**를 선택합니다. 목록에서 새 스택 세트를 선택합니다.

1. **스택 인스턴스** 탭을 선택합니다. 제공한 각 계정의 스택 인스턴스 1개가 us-east-1 리전에서 생성되었는지 확인합니다. 각 스택 인스턴스의 상태가 `CURRENT`인지 확인하세요.

## 4단계: CloudFormationStackInstances 작업 추가
<a name="tutorials-stacksets-instances"></a>

파이프라인에서 CloudFormation StackSets가 나머지 스택 인스턴스를 생성할 수 있도록 허용하는 다음 작업을 생성합니다.

**파이프라인에서 다음 작업을 만들려면**

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔을 엽니다.

   **파이프라인**에서 파이프라인을 선택하고 **보기**를 선택합니다. 다이어그램은 파이프라인 소스 및 배포 단계를 보여줍니다.

1. 파이프라인을 편집하도록 선택합니다. 파이프라인이 **편집** 모드에 표시됩니다.

1. **배포** 단계에서 **편집**을 선택합니다.

1. **AWS CloudFormation 스택 세트** 배포 작업에서 **작업 그룹 추가**를 선택합니다.

1. **작업 편집** 페이지에서 작업 세부 정보를 추가합니다.

   1. **작업 이름**에 작업 이름을 입력합니다.

   1. **작업 공급자**에서 **AWS CloudFormation 스택 인스턴스**를 선택합니다.

   1. **입력 아티팩트**에서 **SourceArtifact**를 선택합니다.

   1. **스택 세트 이름**에 스택 세트의 이름을 입력합니다. 첫 번째 작업에서 제공한 스택 세트의 이름입니다.

   1. **배포 대상**에서 계정 파일을 업로드한 아티팩트 이름과 파일 경로를 입력합니다. 예를 들어, 기본 소스 아티팩트 이름 `SourceArtifact`를 사용하여 다음을 입력합니다.

      ```
      SourceArtifact::accounts.txt
      ```

   1. **배포 대상 AWS 리전**에 다음과 같이 `us-east-2` 및와 같이 나머지 스택 인스턴스를 배포할 리전`eu-central-1`을 입력합니다.

      ```
      us-east2, eu-central-1
      ```

   1. **내결함성 비율**에 `20`을 입력합니다.

   1. **최대 동시 비율**에 `25`를 입력합니다.

   1. **저장**을 선택합니다.

   1. .변경 사항을 수동으로 릴리스합니다. 업데이트된 파이프라인은 배포 단계에서 두 가지 작업과 함께 표시됩니다.

## 5단계: 배포를 위한 스택 세트 리소스 보기
<a name="tutorials-stacksets-view"></a>

스택 세트 배포에 대한 리소스와 상태를 확인할 수 있습니다.

**리소스를 보려면**

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔을 엽니다.

1. **파이프라인**에서 파이프라인을 선택한 후 **보기**를 선택합니다. 다이어그램은 파이프라인 소스 및 배포 단계를 보여줍니다.

1. 파이프라인의 CloudFormation 작업에 대한 **`AWS CloudFormation Stack Instances`** 작업을 선택합니다. 스택 세트의 템플릿, 리소스 및 이벤트는 CloudFormation 콘솔에 표시됩니다.

1. 왼쪽 탐색 창에서 **StackSets**를 선택합니다. 목록에서 스택 세트를 선택합니다.

1. **스택 인스턴스** 탭을 선택합니다. 제공한 각 계정의 나머지 모든 스택 인스턴스가 예상 리전에서 생성되거나 업데이트되었는지 확인하세요. 각 스택 인스턴스의 상태가 `CURRENT`인지 확인하세요.

## 6단계: 스택 세트 업데이트
<a name="tutorials-stacksets-update"></a>

스택 세트를 업데이트하고 인스턴스에 업데이트를 배포합니다. 이 예시에서는 업데이트를 위해 지정하려는 배포 대상도 변경합니다. 업데이트에 포함되지 않은 인스턴스는 오래됨 상태로 전환됩니다.

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔을 엽니다.

1. **파이프라인**에서 파이프라인을 선택한 후 **편집**을 선택합니다. **배포** 단계에서 **편집**을 선택합니다.

1. 파이프라인에서 **AWS CloudFormation 스택 세트** 작업을 편집하도록 선택합니다. **설명**에서 스택 세트에 대한 새 설명으로 기존 설명을 덮어씁니다.

1. 파이프라인에서 **AWS CloudFormation 스택 인스턴스** 작업을 편집하도록 선택합니다. **배포 대상 AWS 리전**에서 작업이 생성될 때 입력한 `us-east-2` 값을 삭제합니다.

1. 변경 사항을 저장합니다. **변경 사항 릴리스**를 선택하여 파이프라인을 실행합니다.

1.  CloudFormation에서 작업을 엽니다. **StackSet 정보** 탭을 선택합니다. **StackSet 설명**에서 새 설명이 표시되는지 확인합니다.

1. **스택 인스턴스** 탭을 선택합니다. **상태**에서 us-east-2의 스택 인스턴스 상태가 `OUTDATED`인지 확인합니다.

# 자습서: 입력 조건으로 파이프라인에 대한 변수 확인 규칙 생성
<a name="tutorials-varcheckrule"></a>

이 자습서에서는 소스 스테이지에서 소스 작업 공급자로 GitHub를 사용하여 파일을 지속적으로 제공하는 파이프라인을 구성합니다. 완성된 파이프 라인은 소스 리포지토리의 소스 파일을 변경할 때 변경 사항을 감지합니다. 파이프라인은 실행된 후, 빌드 스테이지에 진입하기 위해 조건에 제공된 소스 리포지토리 이름 및 브랜치 이름과 비교하여 출력 변수를 확인합니다.

**중요**  
파이프라인 생성의 일환으로 CodePipeline은 고객이 제공하는 S3 아티팩트 버킷을 아티팩트에 사용합니다. (이는 S3 소스 작업에 사용되는 버킷과 다릅니다.) S3 아티팩트 버킷이 파이프라인의 계정과 다른 계정에 있는 경우 S3 아티팩트 버킷을 안전하고 신뢰할 수 AWS 계정 있는에서 소유해야 합니다.

**중요**  
이 절차에서 파이프라인에 추가하는 많은 작업에는 파이프라인을 생성하기 전에 생성해야 하는 AWS 리소스가 포함됩니다. 소스 작업에 대한 AWS 리소스는 항상 파이프라인을 생성하는 리전과 동일한 AWS 리전에서 생성해야 합니다. 예를 들어, 미국 동부(오하이오) 리전에서 파이프라인을 생성하는 경우, CodeCommit 리포지토리도 미국 동부(오하이오) 리전에 있어야 합니다.  
파이프라인을 생성할 때 교차 리전 작업을 추가할 수 있습니다. 교차 리전 작업에 대한 AWS 리소스는 작업을 실행하려는 리전과 동일한 AWS 리전에 있어야 합니다. 자세한 내용은 [CodePipeline에 교차 리전 작업 추가](actions-create-cross-region.md) 단원을 참조하십시오.

이 예제에서는 GitHub(버전 2) 소스 작업과 CodeBuild 빌드 작업이 있는 예제 파이프라인을 사용합니다. 여기서 빌드 스테이지의 입력 조건에 변수가 있는지 확인합니다.

## 사전 조건
<a name="tutorials-varcheckrule-prereq"></a>

시작하기 전에 다음을 수행해야 합니다.
+ GitHub 계정을 사용하여 GitHub 리포지토리를 만듭니다.
+ GitHub 자격 증명을 준비합니다. AWS Management Console 를 사용하여 연결을 설정하면 GitHub 자격 증명으로 로그인하라는 메시지가 표시됩니다.
+ 리포지토리에 연결하여 GitHub(GitHub 앱 사용)를 파이프라인의 소스 작업으로 설정합니다. GitHub 리포지토리에 대한 연결을 생성하려면 [GitHub 연결](connections-github.md) 섹션을 참조하세요.

## 1단계: 샘플 소스 파일을 생성하고 GitHub 리포지토리에 추가
<a name="tutorials-varcheckrule-push"></a>

이 섹션에서는 파이프라인이 소스 스테이지에 대해 사용하는 리포지토리에 예제 소스 파일을 생성하고 추가합니다. 이 예제에서는 다음을 생성하고 추가합니다.
+ `README.md` 파일.

GitHub 리포지토리를 만든 후 다음 단계를 사용하여 README 파일을 추가합니다.

1. GitHub 리포지토리에 로그인하고 리포지토리를 선택합니다.

1. 새 파일을 생성하려면 **파일 추가**를 선택한 다음 **새 파일 생성**을 선택합니다. 파일 이름을 `README.md`로 지정하고 다음 텍스트를 추가합니다.

   ```
   This is a GitHub repository!
   ```

1. **변경 사항 커밋**을 선택합니다. 이 자습서의 목적상 다음 예제와 같이 대문자로 표시된 ‘Update’가 포함된 커밋 메시지를 추가합니다.

   ```
   Update to source files
   ```
**참고**  
문자열에 대한 규칙 확인은 대소문자를 구분합니다.

   `README.md` 파일이 리포지토리의 루트 수준에 있는지 확인합니다.

## 2단계: 파이프라인 생성
<a name="tutorials-varcheckrule-create-pipeline"></a>

이 단원에서는 다음 작업을 통해 파이프라인을 생성합니다.
+ GitHub 리포지토리 및 작업에 대한 연결이 있는 소스 단계입니다.
+ 변수 확인 규칙에 대해 입력 시 조건이 구성된 CodeBuild 빌드 스테이지입니다.

**마법사를 사용하여 파이프라인을 생성하려면**

1. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)에서 CodePipeline 콘솔에 로그인합니다.

1. **Welcome(시작)** 페이지, **시작하기** 페이지 또는 **Pipelines(파이프라인)** 페이지에서 **파이프라인 생성**을 선택합니다.

1. **1단계: 생성 옵션 선택** 페이지의 **생성 옵션**에서 **사용자 지정 파이프라인 빌드** 옵션을 선택합니다. **다음**을 선택합니다.

1. **2단계: 파이프라인 설정 선택**의 **파이프라인 이름**에 **MyVarCheckPipeline**을 입력합니다.

1. CodePipeline은 특성과 가격이 다른 V1 및 V2 유형 파이프라인을 제공합니다. V2 유형은 콘솔에서 선택할 수 있는 유일한 유형입니다. 자세한 내용은 [파이프라인 유형](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)을 참조하세요. CodePipeline에 대한 요금 정보는 [요금](https://aws.amazon.com/codepipeline/pricing/)을 참조하세요.

1. **Service role(서비스 역할)**에서 **New service role(새 서비스 역할)**을 선택합니다.
**참고**  
역할을 생성하지 않고 기존 CodePipeline 서비스 역할을 사용할 경우 서비스 역할 정책에 대한 `codeconnections:UseConnection` IAM 권한을 추가해야 합니다. CodePipeline 서비스 역할에 대한 지침은 [CodePipeline 서비스 역할에 권한 추가](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)를 참조하세요.

1. **고급 설정**에서 기본값을 그대로 둡니다.

   **다음**을 선택합니다.

1. **3단계: 소스 스테이지 추가** 페이지에서 소스 스테이지를 추가합니다.

   1. **소스 공급자**에서 **GitHub(GitHub 앱 사용)**를 선택합니다.

   1. **연결**에서 기존 연결을 선택하거나 새로 생성합니다. GitHub 소스 작업에 대한 연결을 만들거나 관리하려면 [GitHub 연결](connections-github.md)을 참조하세요.

   1. **리포지토리 이름**에서 GitHub 리포지토리의 이름을 선택합니다.

   1. **브랜치 이름**에서 사용할 리포지토리 브랜치를 선택합니다.

   1. **트리거 없음** 옵션이 선택되어 있는지 확인합니다.

   **다음**을 선택합니다.

1. **4단계: 빌드 스테이지 추가**에서 빌드 스테이지를 추가합니다.

   1. **빌드 공급자**에서 **AWS CodeBuild**를 선택합니다. **리전**이 파이프라인 리전으로 기본 설정되도록 합니다.

   1. **프로젝트 생성**을 선택합니다.

   1. **프로젝트 이름**에 이 빌드 프로젝트의 이름을 입력합니다.

   1. **환경 이미지**에서 **이미지 관리**를 선택합니다. [**Operating system**]에서 [**Ubuntu**]를 선택합니다.

   1. **실행 시간**에서 **표준**을 선택합니다. **이미지**에서 **aws/codebuild/standard:5.0**을 선택합니다.

   1. **서비스 역할**에서 **New service role(새 서비스 역할)**을 선택합니다.
**참고**  
CodeBuild 서비스 역할의 이름을 기록해 둡니다. 이 자습서의 마지막 단계를 수행하려면 역할 이름이 필요합니다.

   1. [**Buildspec**]의 [**빌드 사양(Build specifications)**]에서 [**빌드 명령 삽입(Insert build commands)**]을 선택합니다. **편집기로 전환**을 선택하고 **빌드 명령**에 다음을 붙여 넣습니다.

      ```
      version: 0.2
      #env:
        #variables:
           # key: "value"
           # key: "value"
        #parameter-store:
           # key: "value"
           # key: "value"
        #git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
          #commands:
            # - command
            # - command
        #pre_build:
          #commands:
            # - command
            # - command
        build:
          commands:
            - 
        #post_build:
          #commands:
            # - command
            # - command
      artifacts:
        files:
           - '*'
          # - location
        name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. **Continue to CodePipeline(CodePipeline으로 계속)**을 선택합니다. 그러면 CodePipeline 콘솔로 돌아가고 구성을 위해 빌드 명령을 사용하는 CodeBuild 프로젝트가 생성됩니다. 빌드 프로젝트는 서비스 역할을 사용하여 AWS 서비스 권한을 관리합니다. 이 단계는 몇 분이 걸릴 수 있습니다.

   1. **다음**을 선택합니다.

1. **5단계: 테스트 스테이지 추가**에서 **테스트 스테이지 건너뛰기**를 선택하고 **건너뛰기**를 다시 선택하여 경고 메시지를 수락합니다.

   **다음**을 선택합니다.

1. **6단계: 배포 단계 추가** 페이지에서 **배포 단계 건너뛰기를** 선택한 다음 다시 **건너뛰기를** 선택하여 경고 메시지를 수락합니다. **다음**을 선택합니다.

1. **7단계: 검토**에서 **파이프라인 생성을** 선택합니다.

## 2단계: 빌드 스테이지를 편집하여 조건 및 규칙 추가
<a name="tutorials-varcheckrule-create-condition"></a>

이 단계에서는 스테이지를 편집하여 변수 확인 규칙에 대한 입력 시 조건을 추가합니다.

1. 파이프라인을 선택한 다음 **편집**을 선택합니다. 빌드 스테이지에 입력 규칙을 추가하려면 선택합니다.

   **규칙 공급자**에서 **VariableCheck**를 선택합니다.

1. **변수**에 확인할 변수를 입력합니다. **값**에 문자열 값을 입력하여 확인된 변수를 확인합니다. 다음 예제 화면에서는 '같음' 검사에 대해 규칙이 생성되고 '포함' 검사에 대해 다른 규칙이 생성됩니다.  
![\['같음' 변수 확인을 위한 규칙 생성 페이지\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/varcheck-tut-create-rule-equals.png)  
![\['포함' 변수 확인을 위한 규칙 생성 페이지\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/varcheck-tut-create-rule-contains.png)

1. **저장**을 선택합니다.

   **완료**를 선택합니다.

## 3단계: 파이프라인 실행 및 확인된 변수 보기
<a name="tutorials-varcheckrule-run"></a>

이 단계에서는 변수 확인 규칙의 확인된 값과 결과를 확인합니다.

1. 다음 예제와 같이 규칙 확인에 성공한 후 확인된 실행을 확인합니다.  
![\[성공한 실행\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/varcheck-tut-run-succeeded.png)

1. **타임라인** 탭에서 변수 정보를 봅니다.  
![\[변수가 성공한 타임라인 탭을 보여주는 기록 페이지\]](http://docs.aws.amazon.com/ko_kr/codepipeline/latest/userguide/images/varcheck-tut-history.png)