AWS Cloud9 는 더 이상 신규 고객이 사용할 수 없습니다. AWS Cloud9 의 기존 고객은 정상적으로 서비스를 계속 이용할 수 있습니다. [자세히 알아보기](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)
기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.
# 에 대한 자습서 AWS Cloud9
를 처음 사용하시나요 AWS Cloud9? [시작하기: 기본 자습서](tutorials-basic.md)에서 IDE를 둘러보십시오.
이 자습서와 샘플 코드를 실험하여 다양한 프로그래밍 언어 및 AWS 서비스와 AWS Cloud9 함께를 사용하여 지식과 신뢰도를 높입니다.
**Topics**
+ [AWS CLI 및 aws-shell 자습서](sample-aws-cli.md)
+ [AWS CodeCommit 자습서](sample-codecommit.md)
+ [Amazon DynamoDB 자습서](sample-dynamodb.md)
+ [AWS CDK 자습서](sample-cdk.md)
+ [LAMP 자습서](sample-lamp.md)
+ [WordPress 자습서](sample-wordpress.md)
+ [Java 자습서](sample-java.md)
+ [C\$1\$1 자습서](sample-cplusplus.md)
+ [Python 자습서](sample-python.md)
+ [.NET 자습서](sample-dotnetcore.md)
+ [Node.js 자습서](sample-nodejs.md)
+ [PHP 자습서](sample-php.md)
+ [Ruby](tutorial-ruby.md)
+ [Go 자습서](sample-go.md)
+ [TypeScript 자습서](sample-typescript.md)
+ [Docker 튜토리얼](sample-docker.md)
+ [관련 자습서](#samples-additonal)
# AWS CLI 및 aws-shell 자습서 AWS Cloud9
다음 자습서에서는 AWS Cloud9 개발 환경에서 AWS Command Line Interface (AWS CLI), aws-shell 또는 둘 다를 설정할 수 있습니다. AWS CLI 및 aws-shell은의 모든 부분과 상호 작용하기 위한 일관된 인터페이스를 제공하는 통합 도구입니다 AWS. AWS CLI 대신를 사용하여와 상호 작용하는 명령을 AWS Management Console 빠르게 실행할 수 있으며 AWS, 이러한 명령 중 일부는 AWS CLI 또는를 사용하여 실행할 수 있습니다 AWS CloudShell.
에 대한 자세한 내용은 [AWS Command Line Interface 사용 설명서를](https://docs.aws.amazon.com/cli/latest/userguide/) AWS CLI참조하세요. aws-shell의 경우 다음 리소스를 참조하세요.
+ GitHub 웹 사이트의 [aws-shell](https://github.com/awslabs/aws-shell)
+ pip 웹 사이트의 [aws-shell](https://pypi.python.org/pypi/aws-shell)
상호 작용하기 AWS CLI 위해에서 실행할 수 있는 명령 목록은 [AWS CLI 명령 참조](https://docs.aws.amazon.com/cli/latest/reference/)를 AWS참조하세요. `aws` 접두사 없이 명령을 시작한다는 점을 AWS CloudShell제외하면와 동일한 명령을 사용할 수 있습니다.
이 샘플을 생성하면 AWS 계정에 요금이 부과될 수 있습니다. 여기에는 Amazon EC2 및 Amazon S3 같은 서비스에 대한 발생할 수 있는 요금이 포함됩니다. 자세한 내용은 [Amazon EC2 요금](https://aws.amazon.com/ec2/pricing/) 및 [Amazon S3 요금](https://aws.amazon.com/s3/pricing/)을 참조하세요.
**Topics**
+ [사전 조건](#sample-aws-cli-prereqs)
+ [1단계: 환경에 AWS CLI, aws-shell 또는 둘 다 설치](#sample-aws-cli-install)
+ [2단계: 환경에서 자격 증명 관리 설정](#sample-aws-cli-creds)
+ [3단계: 환경에서 AWS CLI 또는 aws-shell을 사용하여 기본 명령 실행](#sample-aws-cli-run)
+ [4단계: 정리](#sample-aws-cli-clean-up)
## 사전 조건
이 샘플을 사용하기 전에 설정이 다음 요구 사항을 충족하는지 확인하세요.
+ **기존 AWS Cloud9 EC2 개발 환경이 있어야 합니다.** 이 샘플에서는 Amazon Linux 또는 Ubuntu 서버를 실행 중인 Amazon EC2 인스턴스에 연결된 EC2 환경이 이미 있다고 가정합니다. 다른 환경 또는 운영 시스템이라면 이 샘플 지침을 관련 도구를 설치하는 데에 적용해야 합니다. 자세한 내용은 [에서 환경 생성 AWS Cloud9](create-environment.md) 단원을 참조하십시오.
+ **기존 환경의 AWS Cloud9 IDE가 이미 열려 있습니다.** 환경을 열면가 웹 브라우저에서 해당 환경의 IDE를 AWS Cloud9 엽니다. 자세한 내용은 [에서 환경 열기 AWS Cloud9](open-environment.md) 단원을 참조하십시오.
## 1단계: 환경에 AWS CLI, aws-shell 또는 둘 다 설치
이 단계에서는 AWS Cloud9 IDE를 사용하여 환경에 AWS CLI, aws-shell 또는 둘 다를 설치하여 상호 작용하는 명령을 실행할 수 있습니다 AWS.
AWS Cloud9 EC2 개발 환경을 사용 중이고 만 사용하려는 경우 로 건너뛸 AWS CLI수 있습니다[3단계: 환경에서 AWS CLI 또는 aws-shell을 사용하여 기본 명령 실행](#sample-aws-cli-run). 이는 AWS CLI 가 EC2 환경에 이미 설치되어 있고 환경에 AWS 액세스 자격 증명 세트가 이미 설정되어 있기 때문입니다. 자세한 내용은 [AWS 관리형 임시 자격 증명](security-iam.md#auth-and-access-control-temporary-managed-credentials) 단원을 참조하십시오.
EC2 환경을 사용하지 않는 경우 다음을 수행하여 AWS CLI를 설치합니다.
1. 환경을 연 상태에서 IDE에서 AWS CLI 가 이미 설치되어 있는지 확인합니다. 이 터미널에서 ** `aws --version` ** 명령을 실행합니다. (터미널 세션을 새로 시작하려면 메뉴 모음에서 **Window(창)**, **New Terminal(새 터미널)**을 선택합니다.) AWS CLI 가 설치된 경우 Python의 버전 번호 및 Amazon EC2 인스턴스 또는 자체 서버의 운영 체제 버전 번호와 같은 정보와 함께 버전 번호가 표시됩니다. AWS CLI 가 설치된 경우 로 건너뜁니다[2단계: 환경에서 자격 증명 관리 설정](#sample-aws-cli-creds).
1. 를 설치하려면 *AWS Command Line Interface 사용 설명서*[의 설치를 AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) AWS CLI참조하세요. 예를 들어 Amazon Linux를 실행하는 EC2 환경의 경우, 터미널에서 한 번에 하나씩 이들 세 명령을 실행하여 AWS CLI를 설치합니다.
```
sudo yum -y update # Install the latest system updates.
sudo yum -y install aws-cli # Install the AWS CLI.
aws --version # Confirm the AWS CLI was installed.
```
예를 들어 Ubuntu Server를 실행하는 EC2 환경의 경우, 터미널에서 한 번에 하나씩 이들 세 명령을 실행하여 AWS CLI를 설치합니다.
```
sudo apt update # Install the latest system updates.
sudo apt install -y awscli # Install the AWS CLI.
aws --version # Confirm the AWS CLI was installed.
```
aws-shell을 설치하려는 경우 다음을 수행합니다.
1. 환경이 열린 상태로, IDE에서 aws-shell이 이미 설치되었는지 확인합니다. 이 터미널에서 ** `aws-shell` ** 명령을 실행합니다. (터미널 세션을 새로 시작하려면 메뉴 모음에서 **Window(창)**, **New Terminal(새 터미널)**을 선택합니다.) aws-shell이 설치된 경우 `aws>` 프롬프트가 표시됩니다. aws-shell이 설치된 경우 [2단계: 환경에서 자격 증명 관리 설정](#sample-aws-cli-creds) 단원으로 이동합니다.
1. aws-shell을 설치하려면 pip를 사용합니다. pip를 사용하려면 Python이 설치되어 있어야 합니다.
Python이 이미 설치되어 있는지 확인하려면(또한 필요한 경우 설치하려면) *Python 샘플*의 [1단계: Python 설치](sample-python.md#sample-python-install)에서 설명하는 지침을 따른 다음 이 주제로 돌아옵니다.
pip가 이미 설치되었는지 확인하려면 터미널에서 ** `pip --version` ** 명령을 실행합니다. pip가 설치되었으면 버전 번호가 표시됩니다. pip가 설치되어 있지 않은 경우 터미널에서 한 번에 하나씩 이들 세 명령을 실행하여 설치합니다.
```
wget https://bootstrap.pypa.io/get-pip.py # Get the pip install file.
sudo python get-pip.py # Install pip. (You might need to run 'sudo python2 get-pip.py' or 'sudo python3 get-pip.py' instead, depending on how Python is installed.)
rm get-pip.py # Delete the pip install file, as it is no longer needed.
```
1. pip를 사용하여 aws-shell을 설치하려면 다음 명령을 실행합니다.
```
sudo pip install aws-shell
```
## 2단계: 환경에서 자격 증명 관리 설정
AWS CLI 또는 aws-shell을 사용하여 AWS 서비스를 호출할 때마다 호출과 함께 자격 증명 세트를 제공해야 합니다. 이러한 자격 증명은 AWS CLI 또는 aws-shell에 해당 호출을 수행할 수 있는 적절한 권한이 있는지 여부를 결정합니다. 자격 증명으로 적절한 권한이 확인되지 않는 경우 호출이 실패합니다.
AWS Cloud9 EC2 개발 환경을 사용하는 경우 로 건너뛸 수 있습니다[3단계: 환경에서 AWS CLI 또는 aws-shell을 사용하여 기본 명령 실행](#sample-aws-cli-run). 이렇게 하는 이유는 EC2 환경에서 이미 자격 증명이 설정되었기 때문입니다. 자세한 내용은 [AWS 관리형 임시 자격 증명](security-iam.md#auth-and-access-control-temporary-managed-credentials) 단원을 참조하십시오.
EC2 환경을 사용하고 있지 않은 경우 환경에서 자격 증명을 수동으로 저장해야 합니다. 이렇게 하려면 [AWS 서비스 의 환경에서 호출 AWS Cloud9](credentials.md) 섹션의 지침을 수행한 다음 이 주제로 돌아옵니다.
## 3단계: 환경에서 AWS CLI 또는 aws-shell을 사용하여 기본 명령 실행
이 단계에서는 환경의 AWS CLI 또는 aws-shell을 사용하여 Amazon S3에서 버킷을 생성하고 사용 가능한 버킷을 나열한 다음 버킷을 삭제합니다.
1. aws-shell을 사용하려고 하지만 아직 시작하지 않은 경우 `aws-shell` 명령을 실행하여 aws-shell을 시작합니다. `aws>` 프롬프트가 표시됩니다.
1. 버킷을 만듭니다. AWS CLI 또는 ** `aws s3 mb` ** 명령을 aws-shell**`s3 mb`**과 함께 실행하여 생성할 버킷의 이름을 제공합니다. 이 예제에서는 이름이 인 버킷을 사용합니다. `cloud9-123456789012-bucket`여기서 `123456789012`는 AWS 계정 ID입니다. 다른 이름을 사용하는 경우 이 단계 전체에서 해당 이름으로 바꿉니다.
```
aws s3 mb s3://cloud9-123456789012-bucket # For the AWS CLI.
s3 mb s3://cloud9-123456789012-bucket # For the aws-shell.
```
**참고**
버킷 이름은 AWS 계정뿐만 AWS아니라 모든에서 고유해야 합니다. 앞에서 제안된 버킷 이름은 고유한 버킷 이름을 제공하는 데 도움이 됩니다. `BucketAlreadyExists` 오류를 포함하는 메시지가 표시되면 다른 버킷 이름과 함께 다시 명령을 실행해야 합니다.
1. 사용 가능한 버킷을 나열합니다. 를 사용하여 ** `aws s3 ls` ** 명령을 실행 AWS CLI 하거나 aws-shell을 사용하여 ** `s3 ls` ** 명령을 실행합니다. 사용 가능한 버킷의 목록이 표시됩니다.
1. 버킷을 삭제합니다. ** `aws s3 rb` ** 명령을 로 실행 AWS CLI 하거나 ** `s3 rb` ** 명령을 aws-shell로 실행하여 삭제할 버킷의 이름을 제공합니다.
```
aws s3 rb s3://cloud9-123456789012-bucket # For the AWS CLI.
s3 rb s3://cloud9-123456789012-bucket # For the aws-shell.
```
버킷이 삭제되었는지 확인하려면 명령을 로 다시 실행 AWS CLI 하거나 ** `aws s3 ls` ** 명령을 aws-shell로 ** `s3 ls` ** 다시 실행합니다. 삭제된 버킷의 이름이 더 이상 목록에 표시되지 않아야 합니다.
**참고**
버킷을 계속 사용하려는 경우 해당 버킷을 삭제할 필요가 없습니다. 자세한 내용은 *Amazon Simple Storage Service 사용 설명서*의 [버킷에 객체 추가](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html)를 참조하세요. *AWS CLI 명령 참조*에서 [s3 명령](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html.html)도 참조하세요. (버킷을 삭제하지 않으면 AWS 계정에 요금이 계속 부과될 수 있습니다.)
를 계속 실험하려면 *AWS Command Line Interface 사용 설명서*의 [Amazon Web Services 작업](https://docs.aws.amazon.com/cli/latest/userguide/chap-working-with-services.html)과 [AWS CLI 명령 참조](https://docs.aws.amazon.com/cli/latest/reference/)를 AWS CLI참조하세요. aws-shell 시험을 계속하려면 [AWS CLI 명령 참조](https://docs.aws.amazon.com/cli/latest/reference/)를 참조하세요. `aws` 접두사를 사용하지 않고 명령을 시작해야 한다는 점에 유의하세요.
## 4단계: 정리
aws-shell을 사용 중인 경우 **`.exit`** 또는 **`.quit`** 명령을 실행하여 사용을 중지할 수 있습니다.
이 샘플 사용을 완료한 후 AWS 계정에 지속적인 요금이 부과되지 않도록 하려면 환경을 삭제해야 합니다. 지침은 [에서 환경 삭제 AWS Cloud9](delete-environment.md) 단원을 참조하세요.
# AWS CodeCommit 에 대한 자습서 AWS Cloud9
자습서를 사용하여 CodeCommit의 원격 코드 AWS CodeCommit 리포지토리와 상호 작용하도록 AWS Cloud9 개발 환경을 설정할 수 있습니다. CodeCommit은 AWS 클라우드에 Git 리포지토리를 비공개로 저장하고 관리하는 데 사용할 수 있는 소스 코드 제어 서비스입니다. CodeCommit에 대한 자세한 내용은 [AWS CodeCommit 사용 설명서](https://docs.aws.amazon.com/codecommit/latest/userguide/)를 참조하세요.
이 자습서를 따르고이 샘플을 생성하면 요금이 발생할 수 있습니다 AWS 계정. 여기에는 Amazon EC2 및 CodeCommit 같은 서비스에 대한 발생할 수 있는 요금이 포함됩니다. 자세한 내용은 [Amazon EC2 요금](https://aws.amazon.com/ec2/pricing/) 및 [AWS CodeCommit 요금](https://aws.amazon.com/codecommit/pricing/)을 참조하세요.
+ [사전 조건](#sample-codecommit-prereqs)
+ [1단계: 필요한 액세스 권한을 사용하여 IAM 그룹 설정](#sample-codecommit-permissions)
+ [2단계:에서 리포지토리 생성 AWS CodeCommit](#sample-codecommit-create-repo)
+ [3단계: 원격 리포지토리에 환경을 연결](#sample-codecommit-connect-repo)
+ [4단계: 원격 리포지토리를 환경에 복제](#sample-codecommit-clone-repo)
+ [5단계: 리포지토리에 파일 추가](#sample-codecommit-add-files)
+ [6단계: 정리](#sample-codecommit-clean-up)
## 사전 조건
이 샘플을 사용하기 전에 설정이 다음 요구 사항을 충족하는지 확인하세요.
+ **기존 AWS Cloud9 EC2 개발 환경이 있어야 합니다.** 이 샘플에서는 Amazon Linux 또는 Ubuntu 서버를 실행 중인 Amazon EC2 인스턴스에 연결된 EC2 환경이 이미 있다고 가정합니다. 다른 환경 또는 운영 시스템이라면 이 샘플 지침을 관련 도구를 설치하는 데에 적용해야 합니다. 자세한 내용은 [에서 환경 생성 AWS Cloud9](create-environment.md) 단원을 참조하십시오.
+ **기존 환경의 AWS Cloud9 IDE가 이미 열려 있습니다.** 환경을 열면가 웹 브라우저에서 해당 환경의 IDE를 AWS Cloud9 엽니다. 자세한 내용은 [에서 환경 열기 AWS Cloud9](open-environment.md) 단원을 참조하십시오.
## 1단계: 필요한 액세스 권한을 사용하여 IAM 그룹 설정
자격 AWS 증명이의 관리자 사용자와 연결되어 AWS 계정있고 해당 사용자를 사용하여 CodeCommit으로 작업하려는 경우에서 [2단계: 리포지토리 생성으로 AWS CodeCommit](#sample-codecommit-create-repo)건너뜁니다.
이 단계는 [AWS Management Console](#sample-codecommit-permissions-console) 또는 [AWS 명령줄 인터페이스(AWS CLI)](#sample-codecommit-permissions-cli)를 사용하여 완료할 수 있습니다.
### 콘솔을 사용하여 필요한 액세스 권한으로 IAM 그룹 설정
1. 아직 로그인하지 않은 경우 AWS Management Console에 로그인합니다.
이 단계에서는 AWS 계정의 관리자 사용자에 대한 보안 인증 정보를 사용하여 로그인하는 것이 좋습니다. 이렇게 할 수 없으면 AWS 계정 관리자에게 문의하세요.
1. IAM 콘솔을 엽니다. 이렇게 하려면 콘솔의 탐색 모음에서 **서비스**를 선택합니다. 그런 다음, **IAM**을 선택합니다.
1. **그룹**을 선택합니다.
1. 그룹의 이름을 선택합니다.
1. **권한** 탭의 **관리형 정책**에서 **정책 연결**을 선택합니다.
1. 정책 이름 목록에서 다음 상자 중 하나를 선택합니다.
+ CodeCommit 및 리포지토리 관련 리소스의 모든 기능에 액세스하려면 **AWS CodeCommitPowerUser**를 선택하세요. 그러나 이렇게 하면 CodeCommit 리포지토리를 삭제하거나 Amazon CloudWatch Events AWS 서비스와 같은 다른에서 리포지토리 관련 리소스를 생성하거나 삭제할 수 없습니다.
+ 에서 CodeCommit 리포지토리 및 관련 리소스를 완전히 제어하려면 **AWSCodeCommitFullAccess**를 선택합니다 AWS 계정. 여기에는 리포지토리 삭제 기능이 포함됩니다.
목록에서 이러한 정책 이름 중 하나가 보이지 않으면 표시할 정책 이름을 **Filter**(필터) 상자에 입력합니다.
1. **정책 연결**을 선택합니다.
이러한 AWS 관리형 정책이 그룹에 부여하는 액세스 권한 목록을 보려면 *AWS CodeCommit 사용 설명서*의에 [AWS 대한 관리형(미리 정의된) 정책을 AWS CodeCommit](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control-iam-identity-based-access-control.html#managed-policies) 참조하세요.
[2단계:에서 리포지토리 생성으로 AWS CodeCommit](#sample-codecommit-create-repo) 건너뜁니다.
### 를 사용하여 필요한 액세스 권한으로 IAM 그룹 설정 AWS CLI
필요한 액세스 권한을 설명하는 AWS 관리형 정책의 그룹 이름과 Amazon 리소스 이름(ARN)을 지정하여 IAM `attach-group-policy` 명령을 실행합니다. 구문은 다음과 같습니다.
```
aws iam attach-group-policy --group-name MyGroup --policy-arn POLICY_ARN
```
앞의 명령에서 `MyGroup`을 그룹의 이름으로 바꿉니다. 를 AWS 관리형 정책의 ARN`POLICY_ARN`으로 바꿉니다.
+ CodeCommit 및 리포지토리 관련 리소스의 모든 기능에 액세스하려면 `arn:aws:iam::aws:policy/AWSCodeCommitPowerUser`를 선택하세요. 그러나 CodeCommit 리포지토리를 삭제하거나 Amazon CloudWatch Events AWS 서비스와 같은 다른에서 리포지토리 관련 리소스를 생성하거나 삭제할 수 없습니다.
+ `arn:aws:iam::aws:policy/AWSCodeCommitFullAccess`에서 CodeCommit 리포지토리 및 관련 리소스를 완전히 제어할 수 있습니다 AWS 계정. 여기에는 리포지토리 삭제 기능이 포함됩니다.
이러한 AWS 관리형 정책이 그룹에 부여하는 액세스 권한 목록을 보려면 *AWS CodeCommit 사용 설명서*의에 [AWS 대한 관리형(미리 정의된) 정책을 AWS CodeCommit](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control-iam-identity-based-access-control.html#managed-policies) 참조하세요.
## 2단계: CodeCommit에서 리포지토리 생성
이 단계에서는 CodeCommit 콘솔을 사용하여 CodeCommit에서 원격 코드 리포지토리를 생성합니다.
이미 CodeCommit 리포지토리가 있으면 [3단계: 원격 리포지토리를 환경에 연결](#sample-codecommit-connect-repo) 섹션으로 건너뜁니다.
이 단계는 [AWS Management Console](#sample-codecommit-create-repo-console) 또는 [AWS 명령줄 인터페이스(AWS CLI)](#sample-codecommit-create-repo-cli)를 사용하여 완료할 수 있습니다.
### 콘솔을 사용하여 CodeCommit에 리포지토리 생성
1. 이전 단계에서 관리자 사용자 AWS Management Console 로에 로그인했으며 관리자 사용자를 사용하여 리포지토리를 생성하지 않으려고 한다고 가정해 보겠습니다. 그런 다음에서 로그아웃합니다 AWS Management Console.
1. [https://console.aws.amazon.com/codecommit](https://console.aws.amazon.com/codecommit)에서 CodeCommit 콘솔을 엽니다.
1. 콘솔의 탐색 모음에서 리전 선택기를 사용하여 리포지토리를 생성할 AWS 리전 (예: **미국 동부(오하이오)**)을 선택합니다.
1. 시작 페이지가 표시되면 [**시작하기(Get started)**]를 선택합니다. 그렇지 않은 경우 [**리포지토리 생성(Create repository)**]을 선택합니다.
1. **Create repository**(리포지토리 생성) 페이지에서 **Repository name**(리포지토리 이름)에 새 리포지토리의 이름(예: `MyDemoCloud9Repo`)을 입력합니다. 다른 이름을 선택하는 경우 이 샘플 전체에서 해당 이름으로 바꿉니다.
1. (선택 사항) **Description**(설명)에 리포지토리에 관한 설명을 입력합니다. 예를 들면 다음과 같이 입력할 수 있습니다. `This is a demonstration repository for the AWS Cloud9 sample.`
1. **리포지토리 생성**을 선택합니다. [**리포지토리에 연결(Connect to your repository)**] 창이 표시됩니다. 이 주제의 뒷부분에서 다른 방법으로 리포지토리에 연결하게 되므로 [**닫기(Close)**]를 선택합니다.
[3단계: 원격 리포지토리를 환경에 연결](#sample-codecommit-connect-repo) 섹션으로 진행합니다.
### 를 사용하여 CodeCommit에서 리포지토리 생성 AWS CLI
AWS CodeCommit `create-repository` 명령을 실행합니다. 리포지토리의 이름, 선택적 설명 및 리포지토리 AWS 리전 를 생성할를 지정합니다.
```
aws codecommit create-repository --repository-name MyDemoCloud9Repo --repository-description "This is a demonstration repository for the AWS Cloud9 sample." --region us-east-2
```
앞의 명령에서 `us-east-2`를 리포지토리를 생성할 AWS 리전 의 ID로 바꿉니다. 지원되는 리전 목록은 **Amazon Web Services 일반 참조의 [AWS CodeCommit](https://docs.aws.amazon.com/general/latest/gr/rande.html#codecommit_region) 섹션을 참조하세요.
다른 이름을 사용하도록 선택하는 경우 이 샘플 전체에서 해당 이름으로 바꿉니다.
## 3단계: 원격 리포지토리에 환경을 연결
이 단계에서는 AWS Cloud9 IDE를 사용하여 이전 단계에서 생성하거나 식별한 CodeCommit 리포지토리에 연결합니다.
**참고**
시각적 인터페이스를 통해 Git로 작업하는 것을 선호하는 경우 원격 리포지토리를 복제할 수 있습니다. 그런 다음, IDE에서 사용할 수 있는 [Git 패널](source-control-gitpanel.md) 기능을 사용하여 파일을 추가할 수 있습니다.
사용 중인 AWS Cloud9 개발 환경의 유형에 따라 다음 절차 중 하나를 완료합니다.
****
| **환경 유형** | **따라야 할 절차** |
| --- | --- |
| EC2 환경 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/cloud9/latest/user-guide/sample-codecommit.html) |
| SSH 환경 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/cloud9/latest/user-guide/sample-codecommit.html) |
## 4단계: 원격 리포지토리를 환경에 복제
이 단계에서는 AWS Cloud9 IDE를 사용하여 CodeCommit의 원격 리포지토리를 환경에 복제합니다.
리포지토리를 복제하려면 **`git clone`** 명령을 실행합니다. `CLONE_URL`을 리포지토리의 클론 URL로 바꿉니다.
```
git clone CLONE_URL
```
EC2 환경의 경우 `https://`로 시작하는 HTTPS 복제 URL을 제공합니다. SSH 환경의 경우 `ssh://`로 시작하는 SSH 복제 URL을 제공합니다.
리포지토리의 전체 복제 URL을 가져오려면 *AWS CodeCommit 사용 설명서*[의 AWS CodeCommit 콘솔을 사용하여 리포지토리 세부 정보 보기를](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-view-repository-details.html#how-to-view-repository-details-console) 참조하세요.
리포지토리에 파일이 없으면 `You appear to have cloned an empty repository.`와 같은 경고 메시지가 표시됩니다. 이는 예상할 수 있는 경우입니다. 나중에 설명하겠습니다.
## 5단계: 리포지토리에 파일 추가
이 단계에서는 AWS Cloud9 환경에 복제된 리포지토리로 세 가지 간단한 파일을 생성합니다. 다음으로 복제된 저장소의 Git 스테이징 영역에 파일을 추가합니다. 마지막으로 준비된 파일을 커밋하고 커밋을 CodeCommit의 원격 리포지토리로 푸시합니다.
복제된 리포지토리의 이 위치에 파일이 이미 있는 경우 작업이 완료되었으며 이 샘플의 나머지 부분을 건너뛸 수 있습니다.
**리포지토리에 파일을 추가하려면**
1. 새 파일을 만듭니다. 메뉴 모음에서 **File(파일)**과 **New File(새 파일)**을 선택합니다.
1. 파일에 다음 콘텐츠를 입력한 다음 **파일**, **저장**을 선택하여 AWS Cloud9 환경의 `MyDemoCloud9Repo` 디렉터리`bird.txt`에 파일을 로 저장합니다.
```
bird.txt
--------
Birds are a group of endothermic vertebrates, characterized by feathers,
toothless beaked jaws, the laying of hard-shelled eggs, a high metabolic
rate, a four-chambered heart, and a lightweight but strong skeleton.
```
**참고**
이 파일을 올바른 디렉터리로 저장하는지 확인하려면 **Save As**(다른 이름으로 저장) 대화 상자에서 `MyDemoCloud9Repo` 폴더를 선택하세요. 그런 다음, **Folder**(폴더)에서 `/MyDemoCloud9Repo`이 표시되는지 확인합니다.
1. 이름이 `insect.txt` 및 `reptile.txt`인 파일을 다음과 같은 내용으로 두 개 더 만듭니다. `MyDemoCloud9Repo` 디렉터리에 파일을 저장합니다.
```
insect.txt
----------
Insects are a class of invertebrates within the arthropod phylum that
have a chitinous exoskeleton, a three-part body (head, thorax, and abdomen),
three pairs of jointed legs, compound eyes, and one pair of antennae.
```
```
reptile.txt
-----------
Reptiles are tetrapod (four-limbed vertebrate) animals in the class
Reptilia, comprising today's turtles, crocodilians, snakes,
amphisbaenians, lizards, tuatara, and their extinct relatives.
```
1. 이 터미널에서는 **`cd`** 명령을 실행하여 `MyDemoCloud9Repo` 디렉터리로 바꿉니다.
```
cd MyDemoCloud9Repo
```
1. **`git status`** 명령을 실행하여 파일이 `MyDemoCloud9Repo` 디렉터리에 성공적으로 저장되었는지 확인합니다. 두 개의 파일 모두 추적되지 않는 파일로 나열됩니다.
```
Untracked files:
(use "git add ..." to include in what will be committed)
bird.txt
insect.txt
reptile.txt
```
1. **`git add`** 명령을 실행하여 파일을 Git 스테이징 지역에 추가합니다.
```
git add --all
```
1. **`git status`** 명령을 다시 실행하여 파일이 Git 스테이징 지역에 성공적으로 추가되었는지 확인합니다. 변경 사항이 커밋되면 세 개 파일 모두가 나열됩니다.
```
Changes to be committed:
(use "git rm --cached ..." to unstage)
new file: bird.txt
new file: insect.txt
new file: reptile.txt
```
1. **`git commit`** 명령을 실행하여 스테이징된 파일을 커밋합니다.
```
git commit -m "Added information about birds, insects, and reptiles."
```
1. **`git push`** 명령을 실행하여 CodeCommit에서 원격 리포지토리로 커밋을 푸시합니다.
```
git push -u origin master
```
1. 파일이 성공적으로 푸시되었는지 확인합니다. 열려 있지 않은 경우 [https://console.aws.amazon.com/codecommit](https://console.aws.amazon.com/codecommit)에서 CodeCommit 콘솔을 엽니다.
1. 상단 탐색 모음의 오른쪽 가장자리 근처에서 리포지토리를 생성한 AWS 리전 를 선택합니다(예: **미국 동부(오하이오)**).
1. [**대시보드(Dashboard)**] 페이지에서 **MyDemoCloud9Repo**를 선택합니다. 세 개의 파일이 표시됩니다.
CodeCommit 리포지토리를 계속 실험하려면 *AWS CodeCommit 사용 설명서*에서 [리포지토리 콘텐츠 검색](https://docs.aws.amazon.com/codecommit/latest/userguide/getting-started-cc.html#getting-started-cc-browse)을 참조하세요.
Git에 익숙하지 않고 CodeCommit 리포지토리에 서툴다면 [Git 시도하기](https://try.github.io/)의 샘플 Git 리포지토리를 먼저 경험해보세요.
## 6단계: 정리
이 샘플 사용을 완료한 AWS 계정 후에 요금이 계속 부과되지 않도록 하려면 CodeCommit 리포지토리를 삭제합니다. 지침은 *AWS CodeCommit 사용 설명서*의 [AWS CodeCommit 리포지토리 삭제](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-delete-repository.html)를 참조하세요.
또한 환경도 삭제해야 합니다. 지침에 대한 내용은 [환경 삭제](delete-environment.md)를 참조하십시오.
# 에 대한 Amazon DynamoDB 자습서 AWS Cloud9
이 자습서를 사용하면 Amazon DynamoDB와 함께 작동하도록 AWS Cloud9 개발 환경을 설정할 수 있습니다.
DynamoDB는 완전관리형 NoSQL 데이터베이스 서비스입니다. DynamoDB를 사용하여 데이터 규모에 관계없이 데이터를 저장 및 검색하고, 어떤 수준의 요청 트래픽이라도 처리할 수 있는 데이터베이스 테이블을 생성할 수 있습니다. DynamoDB는 테이블의 데이터와 트래픽을 충분한 수의 서버로 자동 분산하여 지정한 요청 용량과 저장된 데이터 규모를 처리하면서도 일관되고 빠른 성능을 발휘합니다. 자세한 내용은 AWS 웹 사이트의 [Amazon DynamoDB](https://aws.amazon.com/dynamodb/)를 참조하세요.
이 샘플을 생성하면 AWS 계정에 요금이 부과될 수 있습니다. 여기에는 Amazon EC2 및 DynamoDB 같은 서비스에 대한 발생할 수 있는 요금이 포함됩니다. 자세한 내용은 [Amazon EC2 요금](https://aws.amazon.com/ec2/pricing/) 및 [Amazon DynamoDB 요금](https://aws.amazon.com/dynamodb/pricing/)을 참조하세요.
추가 AWS 데이터베이스 상품에 대한 자세한 내용은 AWS 웹 사이트의 [Amazon Relational Database Service(RDS),](https://aws.amazon.com/rds/) [Amazon ElastiCache](https://aws.amazon.com/elasticache/) 및 [Amazon Redshift](https://aws.amazon.com/redshift/)를 참조하세요. AWS 웹 사이트에서 [AWS Database Migration Service](https://aws.amazon.com/dms/) 섹션도 참조하세요.
+ [사전 조건](#sample-dynamodb-prereqs)
+ [1단계: 환경에 AWS CLI, AWS CloudShell또는 두 가지 모두를 설치하거나 구성](#sample-dynamodb-cli-setup)
+ [2단계: 테이블 생성](#sample-dynamodb-create-table)
+ [3단계: 테이블에 항목 추가](#sample-dynamodb-add-item)
+ [4단계: 테이블에 여러 항목 추가](#sample-dynamodb-add-items)
+ [5단계: 글로벌 보조 인덱스 생성](#sample-dynamodb-create-index)
+ [6단계: 테이블에서 항목 가져오기](#sample-dynamodb-get-items)
+ [7단계: 정리](#sample-dynamodb-clean-up)
## 사전 조건
이 샘플을 사용하기 전에 설정이 다음 요구 사항을 충족하는지 확인하세요.
+ **기존 AWS Cloud9 EC2 개발 환경이 있어야 합니다.** 이 샘플에서는 Amazon Linux 또는 Ubuntu 서버를 실행 중인 Amazon EC2 인스턴스에 연결된 EC2 환경이 이미 있다고 가정합니다. 다른 환경 또는 운영 시스템이라면 이 샘플 지침을 관련 도구를 설치하는 데에 적용해야 합니다. 자세한 내용은 [에서 환경 생성 AWS Cloud9](create-environment.md) 단원을 참조하십시오.
+ **기존 환경의 AWS Cloud9 IDE가 이미 열려 있습니다.** 환경을 열면가 웹 브라우저에서 해당 환경의 IDE를 AWS Cloud9 엽니다. 자세한 내용은 [에서 환경 열기 AWS Cloud9](open-environment.md) 단원을 참조하십시오.
## 1단계: 환경에 AWS CLI AWS CloudShell, 또는 둘 다 설치 및 구성
이 단계에서는 AWS Cloud9 DynamoDB와 상호 작용하는 명령을 실행할 수 있도록 IDE를 사용하여 환경에 AWS CLI AWS CloudShell, 또는 둘 다를 설치하고 구성합니다. 그런 다음 AWS CLI 를 사용하여 기본 DynamoDB 명령을 실행함으로써 설치 및 구성을 테스트합니다.
1. AWS CLI 또는에 대한 자격 증명 관리를 설정하고 환경에 AWS CLI, AWS CloudShell또는 둘 다를 AWS CloudShell 설치하려면 [AWS CLI 및 AWS CloudShell 샘플](sample-aws-cli.md)의 1단계와 2단계를 수행한 다음이 주제로 돌아갑니다. 환경에 AWS CLI, AWS CloudShell또는 둘 다를 이미 설치하고 구성한 경우 다시 할 필요가 없습니다.
1. 환경의 터미널 세션에서 DynamoDB** `list-tables` ** 명령을 실행하여 기존 DynamoDB 테이블이 있는 경우 나열하여 , AWS CLI aws-shell 또는 둘 다의 설치 및 구성을 테스트합니다. 터미널 세션을 새로 시작하려면 메뉴 모음에서 [**창(Window)**], [**새 터미널(New Terminal)**]을 선택합니다.
```
aws dynamodb list-tables # For the AWS CLI.
dynamodb list-tables # For the aws-shell.
```
**참고**
이 샘플 전체에서 aws-shell을 사용하는 경우 `aws`로 시작하는 각 명령에서 `aws`를 생략합니다. aws-shell을 시작하려면** `aws-shell` **명령을 실행합니다. aws-shell의 사용을 중지하려면** `.exit` **또는** `.quit` **명령을 실행합니다.
이 명령이 성공하면 이미 있는 기존 DynamoDB 테이블 목록이 포함된 `TableNames` 배열이 출력됩니다. 아직 DynamoDB 테이블이 없는 경우 `TableNames` 배열은 비어 있습니다.
```
{
"TableNames": []
}
```
DynamoDB 테이블이 있는 경우 `TableNames` 배열에는 테이블 이름 목록이 들어 있습니다.
## 2단계: 테이블 생성
이 단계에서는 DynamoDB에서 테이블을 생성하고 테이블의 이름, 레이아웃, 단순 기본 키 및 데이터 처리량 설정을 지정합니다.
`Weather`라는 이 샘플 테이블에는 미국의 일부 도시에 대한 일기 예보에 대한 정보가 포함되어 있습니다. 이 테이블에는 다음과 같은 유형의 정보가 들어 있습니다(DynamoDB에서는 각 정보를 *속성*이라고 함).
+ 필요한 고유 도시 ID(`CityID`)
+ 필수 예보 일자(`Date`)
+ 도시 이름(`City`)
+ 주 이름(`State`)
+ 예보 기상 조건(`Conditions`)
+ 예보 기온(`Temperatures`)
+ 예보 최고 기온, 화씨 단위(`HighF`)
+ 예보 최저 기온, 화씨 단위(`LowF`)
테이블을 생성하려면 AWS Cloud9 IDE의 터미널 세션에서 DynamoDB** `create-table` ** 명령을 실행합니다.
```
aws dynamodb create-table \
--table-name Weather \
--attribute-definitions \
AttributeName=CityID,AttributeType=N AttributeName=Date,AttributeType=S \
--key-schema \
AttributeName=CityID,KeyType=HASH AttributeName=Date,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5
```
이 명령에서:
+ `--table-name`은 테이블 이름을 나타냅니다(이 샘플의 경우 `Weather`). 테이블 이름은 계정 AWS 의 각 AWS 리전 내에서 고유해야 합니다.
+ `--attribute-definitions`는 테이블 항목을 고유하게 식별하는 데 사용되는 속성을 나타냅니다. 이 테이블의 각 항목은 숫자 `ID` 속성과 ISO-8601 형식의 문자열로 표현되는 `Date` 속성의 조합으로 고유하게 식별됩니다.
+ `--key-schema`는 테이블의 키 스키마를 나타냅니다. 이 테이블은 `CityID` 및 `Date`의 복합 기본 키를 갖고 있습니다. 즉, 각 테이블 항목은 반드시 `CityID` 속성 값과 `Date` 속성 값을 가져야 하지만, 테이블의 두 항목이 모두 동일한 `CityID` 속성 값과 `Date` 속성 값을 가질 수 있습니다.
+ `--provisioned-throughput`은 테이블의 읽기/쓰기 용량을 나타냅니다. DynamoDB는 최대 4KB 크기의 항목에 대해 초당 강력히 일관된 읽기 5회 또는 최대 4KB 크기의 항목에 대해 초당 최종적으로 일관된 읽기 5회를 허용합니다. 또한 DynamoDB는 크기가 최대 1KB인 항목에 대해 초당 최대 5회의 쓰기를 허용합니다.
**참고**
프로비저닝된 처리량을 높게 설정하면 AWS 계정에 추가 요금이 발생할 수 있습니다.
이 명령과 다른 DynamoDB 명령에 대한 자세한 내용은 *AWS CLI 명령 참조*에서 [dynamodb](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/index.html)를 참조하세요.
이 명령이 성공하면 생성 중인 새 테이블에 대한 요약 정보가 표시됩니다. 테이블이 성공적으로 생성되었는지 확인하려면 테이블 이름(`--table-name`)을 지정하여 DynamoDB** `describe-table` **명령을 실행합니다.
```
aws dynamodb describe-table --table-name Weather
```
테이블이 성공적으로 생성되면 `TableStatus` 값이 `CREATING`에서 `ACTIVE`로 바뀝니다. 테이블이 성공적으로 생성될 때까지 이 단계를 넘어가지 마세요.
## 3단계: 테이블에 항목 추가
이 단계에서는 방금 생성한 테이블에 항목을 추가합니다.
1. 다음 콘텐츠가 포함된 `weather-item.json`이라는 파일을 생성합니다. 새 파일을 생성하려면 메뉴 모음에서 [**파일(File)**], [**새 파일(New File)**]을 선택합니다. 파일을 저장하려면 **File(파일)**, **Save(저장)**를 선택합니다.
```
{
"CityID": { "N": "1" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "46" }
}
}
}
```
이 코드에서 `N`은 숫자인 속성 값을 나타냅니다. `S`는 문자열 속성 값입니다. `M`은 속성-값 페어의 세트인 맵 속성입니다. 항목 작업을 할 때마다 속성의 데이터 유형을 지정해야 합니다. 사용 가능한 추가 속성 데이터 형식은 *Amazon DynamoDB 개발자 가이드*에서 [데이터 형식](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes)을 참조하세요.
1. 테이블 이름(`--table-name`)과 JSON 형식의 항목(`--item`)에 대한 경로를 지정하여 DynamoDB** `put-item` **명령을 실행합니다.
```
aws dynamodb put-item \
--table-name Weather \
--item file://weather-item.json
```
명령이 성공하면 오류 없이 실행되며 확인 메시지가 표시되지 않습니다.
1. 테이블의 현재 콘텐츠를 확인하려면 테이블 이름(`--table-name`)을 지정하여 DynamoDB** `scan` **명령을 실행합니다.
```
aws dynamodb scan --table-name Weather
```
명령이 성공하면 테이블 및 방금 추가한 항목에 대한 요약 정보가 표시됩니다.
## 4단계: 테이블에 여러 항목 추가
이 단계에서는 `Weather` 테이블에 항목을 몇 개 더 추가합니다.
1. 다음 콘텐츠가 포함된 `more-weather-items.json`이라는 파일을 생성합니다.
```
{
"Weather": [
{
"PutRequest": {
"Item": {
"CityID": { "N": "1" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "52" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "1" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "49" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Thunderstorms" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "51" },
"LowF": { "N": "41" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Rain Showers" },
"Temperatures": { "M": {
"HighF": { "N": "49" },
"LowF": { "N": "39" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "40" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Partly Sunny" },
"Temperatures": { "M": {
"HighF": { "N": "54" },
"LowF": { "N": "37" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Mostly Sunny" },
"Temperatures": { "M": {
"HighF": { "N": "53" },
"LowF": { "N": "37" }
}
}
}
}
}
]
}
```
이 코드에서는 8개의 `Item` 객체는 이전 단계에서 정의한 단일 항목과 유사하게 테이블에 추가할 8개 항목을 정의합니다. 그러나 다음 단계에서 DynamoDB** `batch-write-item` **명령을 실행할 때 포함하는 `PutRequest` 객체에 각 `Item` 객체를 포함하는 JSON 형식 객체를 제공해야 합니다. 그런 다음 해당 `PutRequest` 객체를 테이블과 같은 이름의 상위 배열에 포함해야 합니다.
1. 추가할 JSON 형식의 항목(`--request-items`)에 대한 경로를 지정하여 DynamoDB** `batch-write-item` **명령을 실행합니다.
```
aws dynamodb batch-write-item \
--request-items file://more-weather-items.json
```
명령이 성공하면 항목이 성공적으로 추가되었음을 확인하는 다음 메시지가 표시됩니다.
```
{
"UnprocessedItems": {}
}
```
1. 테이블의 현재 콘텐츠를 확인하려면 DynamoDB** `scan` **명령을 다시 실행합니다.
```
aws dynamodb scan --table-name Weather
```
이 명령이 성공하면 9개의 항목이 표시됩니다.
## 5단계: 글로벌 보조 인덱스 생성
DynamoDB** `scan` **명령을 실행하여 항목에 대한 정보를 얻으려면 속도가 느릴 수 있습니다. 테이블의 크기가 커지거나 얻으려는 정보 유형이 복잡할 때 특히 그렇습니다. 하나 이상의 보조 인덱스를 생성하여 보다 쉽게 정보를 얻을 수 있습니다. 이 단계에서는 DynamoDB 가 지원하는 두 가지 유형의 보조 인덱스에 대해 알아봅니다. 이를 *로컬 보조 인덱스* 및 *글로벌 보조 인덱스*라고 합니다. 다음으로 글로벌 보조 인덱스를 생성합니다.
이러한 보조 인덱스 유형을 이해하려면 먼저 테이블의 항목을 고유하게 식별하는 기본 키에 대해 알아야합니다. DynamoDB는 *단순 기본 키* 또는 *복합 기본 키*를 지원합니다. 단순 기본 키에는 단일 속성이 있으며 해당 속성 값은 테이블의 각 항목에 대해 고유해야 합니다. 이 속성을 *파티션 키*(또는*해시 속성*)이라고도 하며 DynamoDB가 빠른 액세스를 위해 항목을 분할하는 데 이 속성을 사용할 수 있습니다. 테이블은 두 개의 속성을 포함하는 복합 기본 키를 가질 수도 있습니다. 첫 번째 속성은 파티션 키이고, 두 번째 속성은 *정렬 키*(*범위 속성*이라고도 함)입니다. 복합 기본 키가 있는 테이블에서 두 항목은 동일한 파티션 키 값을 가질 수 있지만 동일한 정렬 키 값까지 가질 수는 없습니다. `Weather` 테이블은 복합 기본 키를 갖고 있습니다.
로컬 보조 인덱스의 파티션 키는 테이블 자체와 동일하지만, 이 인덱스 유형의 정렬 키는 다를 수 있습니다. 글로벌 보조 인덱스는 파티션 키 및 정렬 키가 모두 테이블 차제와 다를 수 있습니다.
예를 들어 기본 키를 사용하여 `CityID`를 기준으로 `Weather` 항목에 액세스할 수 있습니다. `State`를 기준으로 `Weather` 항목에 액세스하려면 파티션 키가 `CityID`(테이블 자체와 동일해야 함)이고 정렬 키가 `State`인 로컬 보조 인덱스를 생성할 수 있습니다. `City`를 기준으로 `Weather` 항목에 액세스하려면 파티션 키가 `City`이고 정렬 키가 `Date`인 글로벌 보조 인덱스를 생성할 수 있습니다.
테이블을 생성하는 동안에만 로컬 보조 인덱스를 생성할 수 있습니다. `Weather` 테이블이 이미 있기 때문에 로컬 보조 인덱스를 추가할 수 없습니다. 하지만 보조 인덱스는 추가할 수 있습니다. 지금 추가해 보세요.
**참고**
보조 인덱스를 생성하면 AWS 계정에 추가 요금이 발생할 수 있습니다.
1. 다음 콘텐츠가 포함된 `weather-global-index.json`이라는 파일을 생성합니다.
```
[
{
"Create": {
"IndexName": "weather-global-index",
"KeySchema": [
{
"AttributeName": "City",
"KeyType": "HASH"
},
{
"AttributeName": "Date",
"KeyType": "RANGE"
}
],
"Projection": {
"ProjectionType": "INCLUDE",
"NonKeyAttributes": [
"State",
"Conditions",
"Temperatures"
]
},
"ProvisionedThroughput": {
"ReadCapacityUnits": 5,
"WriteCapacityUnits": 5
}
}
}
]
```
이 코드에는 다음이 포함됩니다.
+ 이 글로벌 보조 인덱스의 이름은 `weather-global-index`입니다.
+ `City` 속성은 파티션 키(해시 속성)이며 `Date` 속성은 정렬 키(범위 속성)입니다.
+ `Projection`은 이 인덱스를 사용하는 테이블 검색과 일치하는 모든 항목에 대해 기본적으로 검색할 속성(해시 속성 및 범위 속성 제외)을 정의합니다. 이 샘플에서 `State`, `Conditions`, `HighF`(`Temperatures`의 일부) 및 `LowF`(역시 `Temperatures`의 일부) 속성(`City` 및 `Date`속성 포함)은 일치하는 모든 항목에 대해 검색됩니다.
+ 테이블과 마찬가지로 글로벌 보조 인덱스는 프로비저닝된 처리량 설정을 정의해야 합니다.
+ `IndexName`, `KeySchema`, `Projection` 및 `ProvisionedThroughput` 설정이 `Create` 객체에 포함되어야 합니다. 이 객체는 다음 단계에서 DynamoDB** `update-table` ** 명령을 실행할 때 생성할 글로벌 보조 인덱스를 정의합니다.
1. DynamoDB** `update-table` **명령을 실행합니다.
```
aws dynamodb update-table \
--table-name Weather \
--attribute-definitions \
AttributeName=City,AttributeType=S AttributeName=Date,AttributeType=S \
--global-secondary-index-updates file://weather-global-index.json
```
이 명령에서:
+ `--table-name`은 업데이트할 테이블의 이름입니다.
+ `--attribute-definitions`는 인덱스에 포함할 속성입니다. 파티션 키가 항상 먼저 나열되고 정렬 키는 항상 두 번째로 나열됩니다.
+ `--global-secondary-index-updates`는 글로벌 보조 인덱스를 정의하는 파일의 경로입니다.
이 명령이 성공하면 생성 중인 새 글로벌 보조 인덱스에 대한 요약 정보가 표시됩니다. 글로벌 보조 인덱스가 성공적으로 생성되었는지 확인하려면 테이블 이름(`--table-name`)을 지정하여 DynamoDB** `describe-table` **명령을 실행합니다.
```
aws dynamodb describe-table --table-name Weather
```
글로벌 보조 인덱스가 성공적으로 생성되면 `TableStatus` 값이 `UPDATING`에서 `ACTIVE`로 바뀌고 `IndexStatus`값이 `CREATING`에서 `ACTIVE`로 바뀝니다. 글로벌 보조 인덱스가 성공적으로 생성될 때까지 이 단계를 넘어가지 마세요. 몇 분 정도 걸릴 수 있습니다.
## 6단계: 테이블에서 항목 가져오기
테이블에서 항목을 가져오는 방법에는 여러 가지가 있습니다. 이 단계에서는 테이블의 기본 키를 사용하고, 테이블의 다른 속성을 사용하고, 글로벌 보조 인덱스를 사용하여 항목을 가져옵니다.
### 항목의 기본 키 값을 기준으로 테이블에서 단일 항목을 가져오려면
항목의 기본 키 값을 알고 있는 경우 DynamoDB 명령** `get-item` **,** `scan` **또는** `query`**를 실행하여 일치하는 항목을 가져올 수 있습니다. 이들 명령의 주요 차이점은 다음과 같습니다.
+ **`get-item`**은 지정된 기본 키와 함께 항목에 대한 속성 세트를 반환합니다.
+ **`scan`**은 테이블 또는 보조 인덱스의 모든 항목에 액세스하여 하나 이상의 항목 및 항목 속성을 반환합니다.
+ **`query`**는 기본 키 값을 기반으로 항목을 찾습니다. 복합 기본 키(파티션 키 및 정렬 키)가 있는 테이블 또는 보조 인덱스를 쿼리할 수 있습니다.
이 샘플에서는 이러한 각 명령을 사용하여 `CityID` 속성 값 `1` 및 `Date` 속성 값 `2017-04-12`를 포함하는 항목을 가져오는 방법을 보여줍니다.
1. DynamoDB** `get-item` **명령을 실행하려면 테이블의 이름(`--table-name`), 기본 키 값(`--key`) 및 표시할 항목의 속성 값(`--projection-expression`)을 지정합니다. `Date`는 DynamoDB에서 예약된 키워드이므로 `Date` 속성 값(`--expression-attribute-names`)에 대한 별칭도 제공해야 합니다(`State`도 예약된 키워드이므로 이후 단계에서 별칭이 제공되는 것을 확인할 수 있음).
```
aws dynamodb get-item \
--table-name Weather \
--key '{ "CityID": { "N": "1" }, "Date": { "S": "2017-04-12" } }' \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
이 명령과 다른 명령에서 항목의 모든 속성을 표시하려면 `--projection-expression`을 포함하지 마세요. 이 예에서는 `--projection-expression`을 포함하지 않으므로 `--expression-attribute-names`를 포함할 필요도 없습니다.
```
aws dynamodb get-item \
--table-name Weather \
--key '{ "CityID": { "N": "1" }, "Date": { "S": "2017-04-12" } }'
```
1. DynamoDB** `scan` **명령을 실행하려면 다음을 지정합니다.
+ 테이블의 이름(`--table-name`).
+ 실행할 검색(`--filter-expression`).
+ 사용할 검색 조건(`--expression-attribute-values`).
+ 일치하는 항목에 대해 표시할 속성 종류(`--select`).
+ 표시할 항목에 대한 속성 값(`--projection-expression`).
+ DynamoDB에서 예약된 키워드를 사용하는 속성이 있는 경우 해당 속성의 별칭(`--expression-attribute-names`).
```
aws dynamodb scan \
--table-name Weather \
--filter-expression "(CityID = :cityID) and (#D = :date)" \
--expression-attribute-values \
'{ ":cityID": { "N": "1" }, ":date": { "S": "2017-04-12" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
1. DynamoDB** `query` **명령을 실행하려면 다음을 지정합니다.
+ 테이블의 이름(`--table-name`).
+ 실행할 검색(`--key-condition-expression`).
+ 검색에 사용할 속성 값(`--expression-attribute-values`).
+ 일치하는 항목에 대해 표시할 속성 종류(`--select`).
+ 표시할 항목에 대한 속성 값(`--projection-expression`).
+ DynamoDB에서 예약된 키워드를 사용하는 속성이 있는 경우 해당 속성의 별칭(`--expression-attribute-names`).
```
aws dynamodb query \
--table-name Weather \
--key-condition-expression "(CityID = :cityID) and (#D = :date)" \
--expression-attribute-values \
'{ ":cityID": { "N": "1" }, ":date": { "S": "2017-04-12" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
**`scan` **명령은 결과를 얻기 위해 9개의 항목을 모두 스캔하는 데 필요한 반면,** `query` **명령은 1개의 항목만 검색하는 데 필요합니다.
### 항목의 기본 키 값을 기준으로 테이블에서 여러 항목을 가져오려면
항목의 기본 키 값을 알고 있는 경우 DynamoDB** `batch-get-item` **명령을 실행하여 일치하는 항목을 가져올 수 있습니다. 이 샘플에서는 이러한 각 명령을 사용하여 `CityID` 속성 값 `3` 및 `Date` 속성 값 `2017-04-13` 또는 `2017-04-14`를 포함하는 항목을 가져오는 방법을 보여줍니다.
가져올 항목을 설명하는 파일의 경로(`--request-items`)를 지정하여 DynamoDB** `batch-get-item` **명령을 실행합니다.
```
aws dynamodb batch-get-item --request-items file://batch-get-item.json
```
이 샘플의 경우 `batch-get-item.json` 파일의 코드는 `Weather` 테이블에서 `CityID`가 `3`이고 `Date`가 `2017-04-13` 또는 `2017-04-14`인 항목을 검색하도록 지정합니다. 검색된 각 항목에 대해 `City`, `State`, `Date` 및 `HighF`(`Temperatures`의 일부)의 속성 값이 표시됩니다(있는 경우).
```
{
"Weather" : {
"Keys": [
{
"CityID": { "N": "3" },
"Date": { "S": "2017-04-13" }
},
{
"CityID": { "N": "3" },
"Date": { "S": "2017-04-14" }
}
],
"ProjectionExpression": "City, #S, #D, Temperatures.HighF",
"ExpressionAttributeNames": { "#S": "State", "#D": "Date" }
}
}
```
### 테이블에서 일치하는 모든 항목을 가져오려면
테이블의 속성 값에 대해 알고 있는 경우 DynamoDB** `scan` **명령을 실행하여 일치하는 항목을 가져올 수 있습니다. 이 샘플에서는 `Conditions` 속성 값에 `Sunny`가 포함되어 있고 `HighF` 속성 값(`Temperatures`의 일부)이 `53`보다 클 경우 날짜를 가져오는 방법을 보여줍니다.
다음을 지정하여 DynamoDB** `scan` **명령을 실행합니다.
+ 테이블의 이름(`--table-name`).
+ 실행할 검색(`--filter-expression`).
+ 사용할 검색 조건(`--expression-attribute-values`).
+ 일치하는 항목에 대해 표시할 속성 종류(`--select`).
+ 표시할 항목에 대한 속성 값(`--projection-expression`).
+ DynamoDB에서 예약된 키워드를 사용하는 속성이 있는 경우 해당 속성의 별칭(`--expression-attribute-names`).
```
aws dynamodb scan \
--table-name Weather \
--filter-expression \
"(contains (Conditions, :sun)) and (Temperatures.HighF > :h)" \
--expression-attribute-values \
'{ ":sun": { "S" : "Sunny" }, ":h": { "N" : "53" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression "City, #S, #D, Conditions, Temperatures.HighF" \
--expression-attribute-names '{ "#S": "State", "#D": "Date" }'
```
### 글로벌 보조 인덱스에서 일치하는 모든 항목을 가져오려면
글로벌 보조 인덱스를 사용하여 검색하려면 DynamoDB** `query` **명령을 사용합니다. 이 샘플에서는 `weather-global-index` 보조 인덱스를 사용하여 `Portland`라는 도시의 `2017-04-13` 및 `2017-04-14` 날짜 예보 조건을 가져오는 방법을 보여줍니다.
다음을 지정하여 DynamoDB** `query` **명령을 실행합니다.
+ 테이블의 이름(`--table-name`).
+ 글로벌 보조 인덱스의 이름(`--index-name`).
+ 실행할 검색(`--key-condition-expression`).
+ 검색에 사용할 속성 값(`--expression-attribute-values`).
+ 일치하는 항목에 대해 표시할 속성 종류(`--select`).
+ DynamoDB에서 예약된 키워드를 사용하는 속성이 있는 경우 해당 속성의 별칭(`--expression-attribute-names`).
```
aws dynamodb query \
--table-name Weather \
--index-name weather-global-index \
--key-condition-expression "(City = :city) and (#D between :date1 and :date2)" \
--expression-attribute-values \
'{ ":city": { "S" : "Portland" }, ":date1": { "S": "2017-04-13" }, ":date2": { "S": "2017-04-14" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression "City, #S, #D, Conditions, Temperatures.HighF" \
--expression-attribute-names '{ "#S": "State", "#D": "Date" }'
```
## 7단계: 정리
이 샘플 사용을 완료한 후 AWS 계정에 요금이 계속 부과되지 않도록 하려면 테이블을 삭제해야 합니다. 테이블을 삭제하면 글로벌 보조 인덱스도 삭제됩니다. 또한 환경도 삭제해야 합니다.
테이블을 삭제하려면 테이블 이름(`--table-name`)을 지정하여 DynamoDB** `delete-table` **명령을 실행합니다.
```
aws dynamodb delete-table --table-name Weather
```
명령이 성공하면 `TableStatus` 값 `DELETING`을 포함하여 테이블에 대한 정보가 표시됩니다.
테이블이 성공적으로 삭제되었는지 확인하려면 테이블 이름(`--table-name`)을 지정하여 DynamoDB** `describe-table` **명령을 실행합니다.
```
aws dynamodb describe-table --table-name Weather
```
테이블이 성공적으로 삭제되면 `Requested resource not found`라는 구문이 포함된 메시지가 표시됩니다.
환경을 삭제하려면 [환경 삭제](delete-environment.md)를 참조하세요.
# AWS CDK 에 대한 자습서 AWS Cloud9
이 자습서에서는 AWS Cloud Development Kit (AWS CDK) AWS Cloud9 개발 환경에서를 사용하는 방법을 보여줍니다. AWS CDK 는 개발자가 AWS 인프라 구성 요소를 코드로 모델링하는 데 사용할 수 있는 소프트웨어 도구 및 라이브러리 세트입니다.
에는 여러 작업을 빠르게 해결하는 데 사용할 수 있는 AWS Construct Library가 AWS CDK 포함되어 있습니다 AWS. 예를 들면 `Fleet` 생성문을 사용하여 코드를 호스트 집합에 코드를 완전하고 안전하게 배포할 수 있습니다. 고유의 생성문을 작성하여 아키텍처의 다양한 요소를 모델링하거나 다른 사람과 공유하거나 커뮤니티에 게시할 수 있습니다. 자세한 내용은 [AWS Cloud Development Kit 개발자 안내서](https://docs.aws.amazon.com/cdk/v2/guide/home.html)를 참조하십시오.
이 자습서를 따르고 이 샘플을 생성하면 AWS 계정에 요금이 발생할 수 있습니다. 여기에는 Amazon EC2, Amazon SNS 및 Amazon SQS 같은 서비스에 대한 발생할 수 있는 요금이 포함됩니다. 자세한 내용은 [Amazon EC2 요금](https://aws.amazon.com/ec2/pricing/), [Amazon SNS 요금](https://aws.amazon.com/sns/pricing/) 및 [Amazon SQS 요금](https://aws.amazon.com/sqs/pricing/)을 참조하세요.
**Topics**
+ [사전 조건](#sample-cdk-prereqs)
+ [1단계: 필수 도구 설치](#sample-cdk-install)
+ [2단계: 코드 추가](#sample-cdk-code)
+ [3단계: 코드 실행](#sample-cdk-run)
+ [4단계: 정리](#sample-cdk-clean-up)
## 사전 조건
이 샘플을 사용하기 전에 설정이 다음 요구 사항을 충족하는지 확인하세요.
+ **기존 AWS Cloud9 EC2 개발 환경이 있어야 합니다.** 이 샘플에서는 Amazon Linux 또는 Ubuntu 서버를 실행 중인 Amazon EC2 인스턴스에 연결된 EC2 환경이 이미 있다고 가정합니다. 다른 환경 또는 운영 시스템이라면 이 샘플 지침을 관련 도구를 설치하는 데에 적용해야 합니다. 자세한 내용은 [에서 환경 생성 AWS Cloud9](create-environment.md) 단원을 참조하십시오.
+ **기존 환경의 AWS Cloud9 IDE가 이미 열려 있습니다.** 환경을 열면가 웹 브라우저에서 해당 환경의 IDE를 AWS Cloud9 엽니다. 자세한 내용은 [에서 환경 열기 AWS Cloud9](open-environment.md) 단원을 참조하십시오.
## 1단계: 필수 도구 설치
이 단계에서는가 TypeScript 프로그래밍 언어로 작성된 샘플을 실행하는 데 AWS CDK 필요한 모든 도구를 환경에 설치합니다.
1. [노드 버전 관리자](#sample-cdk-install-nvm) 또는 ** `nvm` ** - 나중에 Node.js를 설치하는 데 사용합니다.
1. 샘플에 필요하고 TypeScript 이상을 설치하는 데 사용하는 Node Package Manager 또는 ** `npm` **가 포함된 [Node.js](#sample-cdk-install-nodejs)입니다 AWS CDK .
1. [TypeScript](#sample-cdk-install-typescript) - 이 샘플에 필요합니다. (는 다른 여러 프로그래밍 언어 AWS CDK 도 지원합니다.)
1. [AWS CDK](#sample-cdk-install-cdk).
### 1.1단계: 노드 버전 관리자(nvm) 설치
1. AWS Cloud9 IDE의 터미널 세션에서 최신 보안 업데이트 및 버그 수정이 설치되어 있는지 확인합니다. 이를 수행하려면** `yum update` **(Amazon Linux) 또는 ** `apt update` ** 명령(Ubuntu Server)을 실행합니다. (터미널 세션을 새로 시작하려면 메뉴 모음에서 **Window(창)**, **New Terminal(새 터미널)**을 선택합니다.)
Amazon Linux의 경우:
```
sudo yum -y update
```
Ubuntu Server:
```
sudo apt update
```
1. **`nvm`**이 이미 설치되었는지 확인합니다. 이렇게 하려면** `--version` **옵션을 사용하여** `nvm` **명령을 실행합니다.
```
nvm --version
```
명령이 성공적으로 실행되면 출력에** `nvm` **버전 번호가 포함되며, [1.2단계: Node.js 설치](#sample-cdk-install-nodejs)로 이동할 수 있습니다.
1. **`nvm`**을 다운로드하여 설치합니다. 이렇게 하려면 설치 스크립트를 실행하십시오. 이 예에서는 v0.33.0이 설치되어 있지만 최신 버전의** `nvm`**을 [여기](https://github.com/nvm-sh/nvm#installing-and-updating)에서 확인할 수 있습니다.
```
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.0/install.sh | bash
```
1. **`nvm`** 사용을 시작합니다. 터미널 세션을 닫고 나서 다시 시작하거나 명령을 포함하는 `~/.bashrc` 파일을 소싱하여 **`nvm`**을 로드합니다.
```
. ~/.bashrc
```
### 1.2단계: Node.js 설치
1. Node.js 설치 여부를 확인하고, 설치한 경우 설치된 버전이 16.17.0 이상인지 확인합니다. **이 샘플은 Node.js 16.17.0에서 테스트되었습니다.** 확인하려면 IDE에 여전히 열려 있는 터미널 세션에서** `--version` ** 옵션을 사용하여** `node` **명령을 실행합니다.
```
node --version
```
Node.js를 설치했으면 출력에 버전 번호가 포함됩니다. 버전 번호가 v16.17.0이면 [1.3단계: TypeScript 설치](#sample-cdk-install-typescript) 섹션으로 이동합니다.
1. **`nvm`** 명령을 **`install`** 작업과 함께 실행하여 Node.js 16을 설치합니다.
**참고**
또한를 실행**`nvm install node`**하여 Node.js의 장기 지원(LTS) 버전을 설치할 수 있습니다. AWS Cloud9 support는 Node.js의 LTS 버전을 추적합니다.
```
nvm install v16
```
1. Node.js 16 사용을 시작합니다. 이렇게 하려면 다음과 같이** `alias` **작업, 별칭을 지정할 버전 번호 및 해당 별칭에 사용할 버전을 사용하여** `nvm` **명령을 실행합니다.
```
nvm alias default 16
```
**참고**
이전 명령은 Node.js 16을 기본 Node.js 버전으로 설정합니다. 또는** `alias` **작업 대신** `use` **작업과 함께** `nvm` **명령을 실행할 수 있습니다(예:** `nvm use 16.17.0` **). 하지만 **`use`** 작업을 지정하면 현재 터미널 세션이 실행 중인 동안에만 Node.js 버전이 실행됩니다.
1. Node.js 16을 사용 중인지 확인하려면 **`node --version`** 명령을 다시 실행합니다. 올바른 버전이 설치된 경우 출력에 버전 v16이 포함됩니다.
### 1.3단계: TypeScript 설치
1. 이미 TypeScript를 설치했는지 여부를 확인합니다. 이렇게 하려면 IDE에 여전히 열려 있는 터미널 세션에서** `--version` **옵션을 사용하여 명령줄 TypeScript 컴파일러를 실행합니다.
```
tsc --version
```
TypeScript를 설치한 경우 출력에 TypeScript 버전 번호가 포함됩니다. TypeScript가 설치된 경우 [1.4단계: 설치 AWS CDK](#sample-cdk-install-cdk) 단원으로 이동합니다.
1. TypeScript를 설치합니다. 이렇게 하려면 ** `install` ** 작업, ** `-g` ** 옵션, TypeScript 패키지의 이름을 사용하여 ** `npm` ** 명령을 실행합니다. 그러면 환경에 TypeScript가 글로벌 패키지로 설치됩니다.
```
npm install -g typescript
```
1. TypeScript가 설치되었는지 확인합니다. 이렇게 하려면 **`--version`** 옵션을 지정하여 명령줄 TypeScript 컴파일러를 실행합니다.
```
tsc --version
```
TypeScript를 설치한 경우 출력에 TypeScript 버전 번호가 포함됩니다.
### 1.4단계: 설치 AWS CDK
1. 가 이미 AWS CDK 설치되어 있는지 확인합니다. 이렇게 하려면 IDE에 여전히 열려 있는 터미널 세션에서** `--version` ** 옵션을 사용하여** `cdk` **명령을 실행합니다.
```
cdk --version
```
AWS CDK 가 설치된 경우 출력에는 AWS CDK 버전 및 빌드 번호가 포함됩니다. [2단계: 코드 추가](#sample-cdk-code) 단원으로 이동합니다.
1. `install` 작업, 설치할 AWS CDK 패키지 이름 및 환경에 패키지를 전역적으로 설치하는 `-g` 옵션과 함께 ** `npm` ** 명령을 실행 AWS CDK 하여를 설치합니다.
```
npm install -g aws-cdk
```
1. AWS CDK 가 설치되고 올바르게 참조되는지 확인합니다. 이렇게 하려면** `--version` **옵션을 사용하여** `cdk` **명령을 실행합니다.
```
cdk --version
```
성공하면 AWS CDK 버전 및 빌드 번호가 표시됩니다.
## 2단계: 코드 추가
이 단계에서는가 AWS CloudFormation 스택을 프로그래밍 방식으로 배포하는 AWS CDK 데 필요한 모든 소스 코드가 포함된 샘플 TypeScript 프로젝트를 생성합니다. 이 스택은 AWS 계정에 Amazon SNS 주제와 Amazon SQS 대기열을 생성한 다음 대기열에서 주제를 구독합니다.
1. IDE에 여전히 열려 있는 터미널 세션을 사용하여 환경에서 프로젝트의 소스 코드를 저장할 디렉터리(예: `~/environment/hello-cdk` 디렉터리)를 생성합니다. 그런 다음 해당 디렉터리로 전환합니다.
```
rm -rf ~/environment/hello-cdk # Remove this directory if it already exists.
mkdir ~/environment/hello-cdk # Create the directory.
cd ~/environment/hello-cdk # Switch to the directory.
```
1. 해당 디렉터리를 AWS CDK에 대한 TypeScript 언어 프로젝트로 설정합니다. 이렇게 하려면 ** `init` ** 작업, ** `sample-app` ** 템플릿, ** `--language` ** 옵션을 프로그래밍 언어의 이름과 함께 사용하여 ** `cdk` ** 명령을 실행합니다.
```
cdk init sample-app --language typescript
```
그러면 다음 파일 및 하위 디렉터리가 해당 디렉터리에 생성됩니다.
+ 숨은 `.git` 하위 디렉터리와 숨은 `.gitignore` 파일 - Git와 같은 소스 제어 도구와 호환되는 프로젝트를 만듭니다.
+ `lib` 하위 디렉터리 - `hello-cdk-stack.ts` 파일을 포함합니다. 이 파일에는 AWS CDK 스택의 코드가 포함되어 있습니다. 이 코드는 이 절차의 다음 단계에 설명되어 있습니다.
+ `bin` 하위 디렉터리 - `hello-cdk.ts` 파일을 포함합니다. 이 파일에는 AWS CDK 앱의 진입점이 포함되어 있습니다.
+ `node_modules` 하위 디렉터리 - 필요 시 앱과 스택에서 사용할 수 있는 지원 코드 패키지가 들어 있습니다.
+ 숨은 `.npmignore` 파일 - 코드 빌드 시 **`npm`**에 필요하지 않은 하위 디렉터리 및 파일 유형을 나열합니다.
+ `cdk.json` 파일 - **`cdk`** 명령을 보다 쉽게 실행할 수 있도록 하는 정보가 들어 있습니다.
+ `package-lock.json` 파일 - **`npm`**에서 발생 가능한 빌드 및 실행 오류를 줄이는 데 사용할 수 있는 정보가 들어 있습니다.
+ `package.json` 파일 - **`npm`** 명령을 좀 더 쉽게 실행하고 빌드 및 실행 오류가 거의 발생하지 않도록 하는 정보가 들어 있습니다.
+ ** `npm` ** 및를 사용하여 실행할 수 있는 유용한 명령을 나열하는 `README.md` 파일입니다 AWS CDK.
+ `tsconfig.json` 파일 - **`tsc`** 명령을 좀 더 쉽게 실행하고 빌드 및 실행 오류가 거의 발생하지 않도록 하는 정보가 들어 있습니다.
1. **Environment(환경)** 창에서 `lib/hello-cdk-stack.ts` 파일을 열고 해당 파일에서 다음 코드를 찾아봅니다.
```
import sns = require('@aws-cdk/aws-sns');
import sqs = require('@aws-cdk/aws-sqs');
import cdk = require('@aws-cdk/cdk');
export class HelloCdkStack extends cdk.Stack {
constructor(parent: cdk.App, name: string, props?: cdk.StackProps) {
super(parent, name, props);
const queue = new sqs.Queue(this, 'HelloCdkQueue', {
visibilityTimeoutSec: 300
});
const topic = new sns.Topic(this, 'HelloCdkTopic');
topic.subscribeQueue(queue);
}
}
```
+ `Stack`, `App`, `StackProps``Queue`, 및 `Topic` 클래스는 CloudFormation 스택 및 해당 속성, 실행 프로그램, Amazon SQS 대기열 및 Amazon SNS 주제를 각각 나타냅니다.
+ `HelloCdkStack` 클래스는이 애플리케이션의 CloudFormation 스택을 나타냅니다. 이 스택에는 이 애플리케이션에 대한 새 Amazon SQS 대기열 및 Amazon SNS 주제가 들어 있습니다.
1. **Environment(환경)** 창에서 `bin/hello-cdk.ts` 파일을 열고 해당 파일에서 다음 코드를 찾아봅니다.
```
#!/usr/bin/env node
import cdk = require('@aws-cdk/cdk');
import { HelloCdkStack } from '../lib/hello-cdk-stack';
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack');
app.run();
```
이 코드는 `lib/hello-cdk-stack.ts` 파일에서 `HelloCdkStack` 클래스를 로드하고 인스턴스화한 후 실행합니다.
1. ** `npm` **를 사용하여 TypeScript 컴파일러를 실행하여 코딩 오류를 확인한 다음가 프로젝트의 `bin/hello-cdk.js` 파일을 실행할 AWS CDK 수 있도록 합니다. 이렇게 하려면 프로젝트의 루트 디렉터리에서 다음과 같이 `package.json` 파일에 ** `build` ** 명령 값을 지정하고 ** `run` ** 작업을 사용하여 ** `npm` ** 명령을 실행합니다.
```
npm run build
```
이전 명령을 실행하면 TypeScript 컴파일러가 실행되어 지원되는 `bin/hello-cdk.d.ts` 및 `lib/hello-cdk-stack.d.ts` 파일이 추가됩니다. 이 컴파일러는 `hello-cdk.ts` 및 `hello-cdk-stack.ts` 파일을 `hello-cdk.js` 및 `hello-cdk-stack.js` 파일로 트랜스컴파일합니다.
## 3단계: 코드 실행
이 단계에서는에 `bin/hello-cdk.js` 파일의 코드를 기반으로 CloudFormation 스택 템플릿을 생성 AWS CDK 하도록 지시합니다. 그런 다음에 스택을 배포 AWS CDK 하도록 지시합니다. 그러면 Amazon SNS 주제와 Amazon SQS 대기열이 생성된 다음 대기열에서 주제를 구독합니다. 그런 다음 주제의 메시지를 대기열로 전송하여 주제 및 대기열이 성공적으로 배포되었는지 확인할 수 있습니다.
1. 에서 CloudFormation 스택 템플릿을 AWS CDK 생성하도록 합니다. 이렇게 하려면 터미널 세션이 아직 열려 있는 상태로, ** `synth` **작업 및 스택의 이름을 사용하여 프로젝트의 루트 디렉터리에서** `cdk` **명령을 실행합니다.
```
cdk synth HelloCdkStack
```
성공하면 출력에 CloudFormation 스택 템플릿의 `Resources` 섹션이 표시됩니다.
1. 특정 AWS 계정 및 AWS 리전 조합의 환경에 AWS CDK 앱을 처음 배포할 때 *부트스트랩 스택*을 설치해야 합니다. 이 스택에는가 다양한 작업을 완료하는 데 AWS CDK 필요한 다양한 리소스가 포함되어 있습니다. 예를 들어이 스택에는가 배포 프로세스 중에 템플릿과 자산을 저장하는 데 AWS CDK 사용하는 Amazon S3 버킷이 포함되어 있습니다. 부트스트랩 스택을 설치하려면** `bootstrap` **작업을 사용하여** `cdk` **명령을 실행합니다.
```
cdk bootstrap
```
**참고**
옵션을 지정`cdk bootstrap`하지 않고를 실행하면 기본 AWS 계정과 AWS 리전이 사용됩니다. 프로필과 계정/리전 조합을 지정하여 특정 환경을 부트스트랩할 수도 있습니다. 예제:
```
cdk bootstrap --profile test 123456789012/us-east-1
```
1. 가 CloudFormation 스택 템플릿을 AWS CDK 실행하여 스택을 배포하도록 합니다. 이렇게 하려면 ** `deploy` **작업 및 스택의 이름을 사용하여 프로젝트의 루트 디렉터리에서** `cdk` **명령을 실행합니다.
```
cdk deploy HelloCdkStack
```
성공하면 출력에 `HelloCdkStack` 스택이 오류 없이 배포되었다는 메시지가 표시됩니다.
**참고**
출력에 스택이 환경을 정의하지 않고 표준 위치에서 AWS 자격 증명을 가져올 수 없거나 리전이 구성되지 않았다는 메시지가 표시되면 IDE에서 자격 AWS 증명이 올바르게 설정되었는지 확인한 다음 ** `cdk deploy` ** 명령을 다시 실행합니다. 자세한 내용은 [AWS 서비스 의 환경에서 호출 AWS Cloud9](credentials.md) 단원을 참조하십시오.
1. Amazon SNS 주제 및 Amazon SQS 대기열이 성공적으로 배포되었는지 확인하려면 메시지를 주제로 전송하고 나서 대기열에 수신된 메시지가 있는지 확인합니다. 이렇게 하려면 AWS Command Line Interface (AWS CLI) 또는와 같은 도구를 사용할 수 있습니다 AWS CloudShell. 이러한 도구에 대한 자세한 내용은 [AWS CLI 및 aws-shell 자습서 AWS Cloud9](sample-aws-cli.md) 단원을 참조하십시오.
예를 들어, IDE에서 터미널 세션이 열려 있는 상태에서 주제에 메시지를 보내려면를 사용하여 Amazon SNS** `publish` ** 명령을 실행 AWS CLI 하고 메시지의 제목 및 본문, 주제의 AWS 리전 및 주제의 Amazon 리소스 이름(ARN)을 제공합니다.
```
aws sns publish --subject "Hello from the AWS CDK" --message "This is a message from the AWS CDK." --topic-arn arn:aws:sns:us-east-2:123456789012:HelloCdkStack-HelloCdkTopic1A234567-8BCD9EFGHIJ0K
```
앞의 명령에서를 주제에 CloudFormation 할당하는 ARN`arn:aws:sns:us-east-2:123456789012:HelloCdkStack-HelloCdkTopic1A234567-8BCD9EFGHIJ0K`으로 바꿉니다. ID를 가져오려면 Amazon SNS** `list-topics` **명령을 실행합니다.
```
aws sns list-topics --output table --query 'Topics[*].TopicArn'
```
성공하면 **`publish`** 명령의 출력에 게시된 메시지에 대한 `MessageId` 값이 표시됩니다.
대기열에서 수신된 메시지가 있는지 확인하려면 대기열의 URL을 지정하여 Amazon SQS** `receive-message` **명령을 실행합니다.
```
aws sqs receive-message --queue-url https://queue.amazonaws.com/123456789012/HelloCdkStack-HelloCdkQueue1A234567-8BCD9EFGHIJ0K
```
앞의 명령에서를 대기열에 CloudFormation 할당하는 ARN`https://queue.amazonaws.com/123456789012/HelloCdkStack-HelloCdkQueue1A234567-8BCD9EFGHIJ0K`으로 바꿉니다. URL을 가져오려면 Amazon SQS** `list-queues` **명령을 실행합니다.
```
aws sqs list-queues --output table --query 'QueueUrls[*]'
```
성공하면 **`receive-message`** 명령의 출력에 수신된 메시지에 대한 정보가 표시됩니다.
## 4단계: 정리
이 샘플 사용을 완료한 후 AWS 계정에 요금이 계속 부과되지 않도록 하려면 CloudFormation 스택을 삭제해야 합니다. 이렇게 하면 Amazon SNS 주제 및 Amazon SQS 대기열이 삭제됩니다. 또한 환경도 삭제해야 합니다.
### 4.1단계: 스택 삭제
터미널 세션이 아직 열려 있는 상태로, ** `destroy` **작업 및 스택의 이름을 사용하여 프로젝트의 루트 디렉터리에서** `cdk` **명령을 실행합니다.
```
cdk destroy HelloCdkStack
```
스택을 삭제할지 묻는 메시지가 표시되면 `y`를 입력하고 나서 `Enter`를 누릅니다.
성공하면 출력에 `HelloCdkStack` 스택이 오류 없이 삭제되었다는 메시지가 표시됩니다.
### 4.2단계: 환경 삭제
환경을 삭제하려면 [에서 환경 삭제 AWS Cloud9](delete-environment.md) 섹션을 참조하세요.
# 에 대한 LAMP 자습서 AWS Cloud9
이 자습서를 통해 AWS Cloud9 개발 환경 내에서 LAMP(Linux, Apache HTTP 서버, MySQL 및 PHP)를 설정하고 실행할 수 있습니다.
이 자습서를 따르고이 샘플을 생성하면 요금이 부과될 수 있습니다 AWS 계정. 여기에는 Amazon Elastic Compute Cloud(Amazon EC2) AWS 서비스 와 같은에 대해 발생할 수 있는 요금이 포함됩니다. 자세한 내용은 [Amazon EC2 요금](https://aws.amazon.com/ec2/pricing/)을 참조하세요.
**Topics**
+ [사전 조건](#sample-lamp-prereqs)
+ [1단계: 도구 설치](#sample-lamp-install-tools)
+ [2단계: MySQL 설정](#sample-lamp-setup-mysql)
+ [3단계: 웹 사이트 설정](#sample-lamp-apache)
+ [4단계: 정리](#sample-lamp-clean-up)
## 사전 조건
이 샘플을 사용하기 전에 설정이 다음 요구 사항을 충족하는지 확인하세요.
+ **기존 AWS Cloud9 EC2 개발 환경이 있어야 합니다.** 이 샘플에서는 Amazon Linux 또는 Ubuntu 서버를 실행 중인 Amazon EC2 인스턴스에 연결된 EC2 환경이 이미 있다고 가정합니다. 다른 환경 또는 운영 시스템이라면 이 샘플 지침을 관련 도구를 설치하는 데에 적용해야 합니다. 자세한 내용은 [에서 환경 생성 AWS Cloud9](create-environment.md) 단원을 참조하십시오.
+ **기존 환경의 AWS Cloud9 IDE가 이미 열려 있습니다.** 환경을 열면가 웹 브라우저에서 해당 환경의 IDE를 AWS Cloud9 엽니다. 자세한 내용은 [에서 환경 열기 AWS Cloud9](open-environment.md) 단원을 참조하십시오.
## 1단계: 도구 설치
이 단계에서는 다음 도구를 설치합니다.
+ Apache HTTP 서버 - 웹 서버 호스트.
+ PHP - 특히 웹 개발에 적합하고 HTML에 포함할 수 있는 스크립팅 언어.
+ MySQL - 데이터베이스 관리 시스템.
그런 다음 Apache HTTP Server와 MySQL을 차례로 시작하여 이 단계를 완료합니다.
1. 최신 보안 업데이트와 버그 수정이 인스턴스에 설치되어 있는지 확인합니다. 이렇게 하려면 AWS Cloud9 IDE의 터미널 세션에서 **`yum update`** for (Amazon Linux) 또는 **`apt update`** for (Ubuntu Server) 명령을 실행합니다. (터미널 세션을 새로 시작하려면 메뉴 모음에서 **Window(창)**, **New Terminal(새 터미널)**을 선택합니다.)
Amazon Linux의 경우:
```
sudo yum -y update
```
Ubuntu 서버용:
```
sudo apt -y update
```
1. Apache HTTP Server가 이미 설치되어 있는지 확인합니다. 이를 수행하려면 **`httpd -v`**(Amazon Linux) 또는 **`apache2 -v`**(Ubuntu Server) 명령을 실행합니다.
성공할 경우, 출력에 Apache HTTP Server 버전 번호가 포함됩니다.
오류가 표시되면 **`install`** 명령을 실행하여 Apache HTTP Server를 설치합니다.
Amazon Linux의 경우:
```
sudo yum install -y httpd24
```
Ubuntu 서버용:
```
sudo apt install -y apache2
```
1. **`php -v`** 명령을 실행하여 PHP가 이미 설치되어 있는지 확인합니다.
성공할 경우, PHP 버전 숫자를 포함해 출력값이 생성됩니다.
오류가 표시되면 **`install`** 명령을 실행하여 PHP를 설치합니다.
Amazon Linux의 경우:
```
sudo yum install -y php56
```
Ubuntu 서버용:
```
sudo apt install -y php libapache2-mod-php php-xml
```
1. **`mysql --version`** 명령을 실행하여 MySQL가 이미 설치되어 있는지 확인합니다.
성공할 경우, 출력에 MySQL 버전 번호가 포함됩니다.
오류가 표시되면 **`install`** 명령을 실행하여 MySQL을 설치합니다.
Amazon Linux의 경우:
```
sudo yum install -y mysql-server
```
Ubuntu 서버용:
```
sudo apt install -y mysql-server
```
1. Apache HTTP Server, PHP, MySQL을 설치한 후 Apache HTTP Server를 시작하고 다음 명령을 실행하여 시작되었는지 확인합니다.
Amazon Linux의 경우(이 명령을 두 번 실행해야 할 수 있음):
```
sudo service httpd start && sudo service httpd status
```
Ubuntu Server의 경우(명령 프롬프트로 돌아가려면 `q`를 누릅니다):
```
sudo service apache2 start && sudo service apache2 status
```
1. MySQL을 시작한 후 다음 명령을 실행하여 시작되었는지 확인합니다.
Amazon Linux의 경우:
```
sudo service mysqld start && sudo service mysqld status
```
Ubuntu Server의 경우(명령 프롬프트로 돌아가려면 `q`를 누릅니다):
```
sudo service mysql start && sudo service mysql status
```
## 2단계: MySQL 설정
이 단계에서는 MySQL 보안 모범 사례를 따르도록 MySQL을 설정합니다. 이러한 보안 모범 사례에는 루트 계정의 암호 설정과 로컬 호스트 외부에서 액세스할 수 있는 루트 계정 제거가 포함됩니다. 염두에 두어야 할 다른 모범 사례로는 익명 사용자 제거, 테스트 데이터베이스 제거, 누구든지 이름이 `test_`로 시작하는 데이터베이스에 액세스할 수 있는 권한 제거 등이 있습니다.
그런 다음 MySQL 명령줄 클라이언트의 시작 및 종료를 연습하여 이 단계를 완료합니다.
1. AWS Cloud9 IDE의 터미널 세션에서 다음 명령을 실행하여 MySQL 설치에 대한 MySQL 보안 모범 사례를 구현합니다.
```
sudo mysql_secure_installation
```
1. 메시지가 표시되면 지정된 대로 다음 질문에 답합니다.
Amazon Linux의 경우:
1. **루트의 현재 암호 입력(입력하지 않으려면 Enter)** - `Enter` 키를 누릅니다(암호가 없는 경우).
1. **루트 암호 설정** - `Y`를 입력한 후 `Enter` 키를 누릅니다.
1. **새 암호** - 암호를 입력한 후 `Enter` 키를 누릅니다.
1. **새 암호 다시 입력** - 암호를 다시 입력한 후 `Enter` 키를 누릅니다. (나중에 사용할 수 있도록 암호를 안전한 위치에 저장해야 합니다.)
1. **익명 사용자 제거** - `Y`를 입력한 후 `Enter` 키를 누릅니다.
1. **원격으로 루트 로그인 허용 안 함** - `Y`를 입력한 후 `Enter` 키를 누릅니다.
1. **테스트 데이터베이스를 제거하고 액세스** - `Y`를 입력한 후 `Enter` 키를 누릅니다.
1. **지금 권한 테이블 다시 로드** - `Y`를 입력한 후 `Enter` 키를 누릅니다.
Ubuntu 서버용:
1. **VALIDATE PASSWORD 플러그인을 설정하시겠습니까** - `y`를 입력한 후 `Enter` 키를 누릅니다.
1. **세 가지 수준의 암호 확인 정책이 있습니다** - `0`, `1` 또는 `2`를 입력한 후 `Enter` 키를 누릅니다.
1. **새 암호** - 암호를 입력한 후 `Enter` 키를 누릅니다.
1. **새 암호 다시 입력** - 암호를 다시 입력한 후 `Enter` 키를 누릅니다. 나중에 사용할 수 있도록 암호를 안전한 위치에 저장해야 합니다.
1. **제공된 암호를 계속 사용하시겠습니까** - `y`를 입력한 후 `Enter` 키를 누릅니다.
1. **익명 사용자 제거** - `y`를 입력한 후 `Enter` 키를 누릅니다.
1. **원격으로 루트 로그인 허용 안 함** - `y`를 입력한 후 `Enter` 키를 누릅니다.
1. **테스트 데이터베이스를 제거하고 액세스** - `y`를 입력한 후 `Enter` 키를 누릅니다.
1. **지금 권한 테이블 다시 로드** - `y`를 입력한 후 `Enter` 키를 누릅니다.
1. MySQL과 직접 상호 작용하려면 다음 명령을 실행하여 MySQL 명령줄 클라이언트를 루트 사용자로 시작합니다. 메시지가 표시되면 앞서 설정한 루트 사용자의 암호를 입력한 후 `Enter`를 누릅니다. MySQL 명령줄 클라이언트에 있는 동안 프롬프트가 `mysql>`로 바뀝니다.
```
sudo mysql -uroot -p
```
1. MySQL 명령줄 클라이언트를 종료하려면 다음 명령을 실행합니다. 프롬프트가 `$`로 다시 바뀝니다.
```
exit;
```
## 3단계: 웹 사이트 설정
이 단계에서는 권장되는 소유자 및 액세스 권한으로 Apache HTTP Server의 기본 웹 사이트 루트를 설정합니다. 그런 다음, 해당 기본 웹 사이트 루트 내에서 PHP 기반 웹 페이지를 만듭니다.
그런 다음 이 EC2 환경과 연결된 Amazon EC2의 보안 그룹과 Amazon Virtual Private Cloud(Amazon VPC)의 네트워크 액세스 제어 목록(네트워크 ACL)을 설정하여 해당 웹 페이지를 보도록 수신 웹 트래픽을 활성화합니다. 각 EC2 환경은 Amazon EC2의 보안 그룹 및 Amazon VPC의 네트워크 ACL과 연결되어 있어야 합니다. 그러나 AWS 계정 의 기본 네트워크 ACL이 환경의 모든 수신 및 발신 트래픽을 허용하는 반면, 기본 보안 그룹은 포트 22를 통해 SSH를 사용하는 수신 트래픽만 허용합니다. 자세한 내용은 [AWS Cloud9 개발 환경에 대한 VPC 설정](vpc-settings.md) 단원을 참조하십시오.
그런 다음 AWS Cloud9 IDE 외부에서 웹 페이지를 봄으로써 이 단계를 완료합니다.
1. 권장되는 소유자 및 액세스 권한으로 Apache HTTP Server의 기본 웹 사이트 루트(`/var/www/html`)를 설정합니다. 이렇게 하려면 AWS Cloud9 IDE의 터미널 세션에서 다음 6개의 명령을 한 번에 하나씩 다음 순서로 실행합니다. 각 명령이 수행하는 작업을 이해하려면 각 명령 뒤의 `#` 문자 뒤의 정보를 읽습니다.
Amazon Linux의 경우:
```
sudo groupadd web-content # Create a group named web-content.
sudo usermod -G web-content -a ec2-user # Add the user ec2-user (your default user for this environment) to the group web-content.
sudo usermod -G web-content -a apache # Add the user apache (Apache HTTP Server) to the group web-content.
sudo chown -R ec2-user:web-content /var/www/html # Change the owner of /var/www/html and its files to user ec2-user and group web-content.
sudo find /var/www/html -type f -exec chmod u=rw,g=rx,o=rx {} \; # Change all file permissions within /var/www/html to user read/write, group read-only, and others read/execute.
sudo find /var/www/html -type d -exec chmod u=rwx,g=rx,o=rx {} \; # Change /var/www/html directory permissions to user read/write/execute, group read/execute, and others read/execute.
```
Ubuntu 서버용:
```
sudo groupadd web-content # Create a group named web-content.
sudo usermod -G web-content -a ubuntu # Add the user ubuntu (your default user for this environment) to the group web-content.
sudo usermod -G web-content -a www-data # Add the user www-data (Apache HTTP Server) to the group web-content.
sudo chown -R ubuntu:web-content /var/www/html # Change the owner of /var/www/html and its files to user ubuntu and group web-content.
sudo find /var/www/html -type f -exec chmod u=rw,g=rx,o=rx {} \; # Change all file permissions within /var/www/html to user read/write, group read-only, and others read/execute.
sudo find /var/www/html -type d -exec chmod u=rwx,g=rx,o=rx {} \; # Change /var/www/html directory permissions to user read/write/execute, group read/execute, and others read/execute.
```
1. 다음 명령을 실행하여 Apache HTTP Server의 기본 웹 사이트 루트 폴더(`/var/www/html`)에 `index.php`라는 PHP 기반 웹 페이지를 만듭니다.
Amazon Linux의 경우:
```
sudo touch /var/www/html/index.php && sudo chown -R ec2-user:web-content /var/www/html/index.php && sudo chmod u=rw,g=rx,o=rx /var/www/html/index.php && sudo printf '%s\n%s\n%s' '' >> /var/www/html/index.php
```
앞의 Amazon Linux용 명령은 파일의 소유자를 `ec2-user`로 변경하고, 파일의 그룹을 `web-content`로 변경하며, 파일의 권한을 사용자의 경우 읽기/쓰기, 그룹 및 기타의 경우 읽기/실행으로 변경합니다.
Ubuntu 서버용:
```
sudo touch /var/www/html/index.php && sudo chown -R ubuntu:web-content /var/www/html/index.php && sudo chmod u=rw,g=rx,o=rx /var/www/html/index.php && sudo printf '%s\n%s\n%s' '' >> /var/www/html/index.php
```
앞의 Ubuntu 서버용 명령은 파일의 소유자를 `ubuntu`로 변경하고, 파일의 그룹을 `web-content`로 변경하며, 파일의 권한을 사용자의 경우 읽기/쓰기, 그룹 및 기타의 경우 읽기/실행으로 변경합니다.
성공하면 앞의 명령이 다음 내용이 포함된 `index.php` 파일을 만듭니다.
```
```
1. Amazon VPC의 네트워크 ACL 및 이 EC2 환경과 연결된 Amazon EC2의 보안 그룹을 설정하여 새 웹 페이지를 보도록 포트 80을 통한 수신 웹 트래픽을 활성화합니다. 이를 수행하려면 다음과 같은 여덟 가지 명령을 다음 순서로 한 번에 하나씩 실행합니다. 각 명령이 수행하는 작업을 이해하려면 각 명령의 `#` 문자 뒤의 정보를 읽습니다.
**중요**
다음 명령을 실행하면 이 환경의 보안 그룹 및 네트워크 ACL과 연결된 **모든** EC2 환경 및 Amazon EC2 인스턴스에 대해 포트 80을 통해 들어오는 웹 트래픽이 허용됩니다. 그러면 이것 외에도 EC2 환경 및 Amazon EC2 인스턴스에 대해 포트 80을 통한 수신 웹 트래픽이 예기치 않게 허용될 수 있습니다.
**참고**
다음 두 번째부터 네 번째 명령은 보안 그룹이 포트 80을 통한 수신 웹 트래픽을 허용할 수 있게 합니다. 포트 22를 통한 수신 SSH 트래픽만 허용하는 기본 보안 그룹이 있는 경우, 첫 번째 명령을 실행한 후 이러한 두 번째부터 네 번째 명령을 실행해야 합니다. 그러나 사용자 지정 보안 그룹이 이미 포트 80을 통한 수신 웹 트래픽을 허용하는 경우, 그러한 명령 실행을 건너뛸 수 있습니다.
다음 다섯 번째부터 여덟 번째 명령은 네트워크 ACL이 포트 80을 통한 수신 웹 트래픽을 허용할 수 있게 합니다. 이미 모든 포트를 통한 모든 수신 트래픽을 허용하는 기본 네트워크 ACL이 있는 경우 그러한 명령 실행을 안전하게 건너뛸 수 있습니다. 하지만 포트 80을 통한 수신 웹 트래픽을 허용하지 않는 사용자 지정 네트워크 ACL이 있다고 가정해 보겠습니다. 그런 다음, 첫 번째 명령을 실행한 후 다섯 번째 명령부터 여덟 번째 명령까지 실행합니다.
```
MY_INSTANCE_ID=$(curl http://169.254.169.254/latest/meta-data/instance-id) # Get the ID of the instance for the environment, and store it temporarily.
MY_SECURITY_GROUP_ID=$(aws ec2 describe-instances --instance-id $MY_INSTANCE_ID --query 'Reservations[].Instances[0].SecurityGroups[0].GroupId' --output text) # Get the ID of the security group associated with the instance, and store it temporarily.
aws ec2 authorize-security-group-ingress --group-id $MY_SECURITY_GROUP_ID --protocol tcp --cidr 0.0.0.0/0 --port 80 # Add an inbound rule to the security group to allow all incoming IPv4-based traffic over port 80.
aws ec2 authorize-security-group-ingress --group-id $MY_SECURITY_GROUP_ID --ip-permissions IpProtocol=tcp,Ipv6Ranges='[{CidrIpv6=::/0}]',FromPort=80,ToPort=80 # Add an inbound rule to the security group to allow all incoming IPv6-based traffic over port 80.
MY_SUBNET_ID=$(aws ec2 describe-instances --instance-id $MY_INSTANCE_ID --query 'Reservations[].Instances[0].SubnetId' --output text) # Get the ID of the subnet associated with the instance, and store it temporarily.
MY_NETWORK_ACL_ID=$(aws ec2 describe-network-acls --filters Name=association.subnet-id,Values=$MY_SUBNET_ID --query 'NetworkAcls[].Associations[0].NetworkAclId' --output text) # Get the ID of the network ACL associated with the subnet, and store it temporarily.
aws ec2 create-network-acl-entry --network-acl-id $MY_NETWORK_ACL_ID --ingress --protocol tcp --rule-action allow --rule-number 10000 --cidr-block 0.0.0.0/0 --port-range From=80,To=80 # Add an inbound rule to the network ACL to allow all IPv4-based traffic over port 80. Advanced users: change this suggested rule number as desired.
aws ec2 create-network-acl-entry --network-acl-id $MY_NETWORK_ACL_ID --ingress --protocol tcp --rule-action allow --rule-number 10100 --ipv6-cidr-block ::/0 --port-range From=80,To=80 # Add an inbound rule to the network ACL to allow all IPv6-based traffic over port 80. Advanced users: change this suggested rule number as desired.
```
1. 웹 서버 루트 내에 `index.php` 파일의 URL을 가져옵니다. 이렇게 하려면 다음 명령을 실행하고 새 웹 브라우저 탭 또는 AWS Cloud9 IDE와 분리된 다른 웹 브라우저를 사용하여 표시되는 URL로 이동합니다. 성공하면 웹 페이지에 Apache HTTP Server, MySQL, PHP 및 기타 관련 설정에 관한 정보가 표시됩니다.
```
MY_PUBLIC_IP=$(curl http://169.254.169.254/latest/meta-data/public-ipv4) && echo http://$MY_PUBLIC_IP/index.php # Get the URL to the index.php file within the web server root.
```
## 4단계: 정리
이 환경을 계속 사용하고 싶지만 포트 80을 통해 들어오는 웹 트래픽을 비활성화하려는 상황을 가정해 보겠습니다. 그렇다면 다음 여덟 가지 명령을 다음 순서로 한 번에 하나씩 실행하여 환경과 연결된 보안 그룹 및 네트워크 ACL에서 앞서 설정한 해당 수신 트래픽 규칙을 삭제합니다. 각 명령이 수행하는 작업을 이해하려면 각 명령의 `#` 문자 뒤의 정보를 읽습니다.
**중요**
다음 명령을 실행하면 이 환경의 보안 그룹 및 네트워크 ACL과 연결된 **모든** EC2 환경 및 Amazon EC2 인스턴스에 대해 포트 80을 통해 들어오는 웹 트래픽이 허용되지 않습니다. 그러면 이것 외에도 EC2 환경 및 Amazon EC2 인스턴스에 대해 포트 80을 통한 수신 웹 트래픽이 예기치 않게 허용되지 않을 수 있습니다.
**참고**
다음 다섯 번째 명령부터 여덟 번째 명령은 네트워크 ACL이 포트 80을 통한 수신 웹 트래픽을 허용하지 못하도록 기존 규칙을 제거합니다. 이미 모든 포트를 통한 모든 수신 트래픽을 허용하는 기본 네트워크 ACL이 있는 경우 그러한 명령 실행을 건너뛸 수 있습니다. 하지만 포트 80을 통한 수신 웹 트래픽을 허용하는 기존 규칙이 포함된 사용자 지정 네트워크 ACL이 있고 해당 규칙을 삭제하려는 경우를 가정해 보겠습니다. 그런 다음, 첫 번째 명령을 실행한 후 다섯 번째 명령부터 여덟 번째 명령까지 실행해야 합니다.
```
MY_INSTANCE_ID=$(curl http://169.254.169.254/latest/meta-data/instance-id) # Get the ID of the instance for the environment, and store it temporarily.
MY_SECURITY_GROUP_ID=$(aws ec2 describe-instances --instance-id $MY_INSTANCE_ID --query 'Reservations[].Instances[0].SecurityGroups[0].GroupId' --output text) # Get the ID of the security group associated with the instance, and store it temporarily.
aws ec2 revoke-security-group-ingress --group-id $MY_SECURITY_GROUP_ID --protocol tcp --cidr 0.0.0.0/0 --port 80 # Delete the existing inbound rule from the security group to block all incoming IPv4-based traffic over port 80.
aws ec2 revoke-security-group-ingress --group-id $MY_SECURITY_GROUP_ID --ip-permissions IpProtocol=tcp,Ipv6Ranges='[{CidrIpv6=::/0}]',FromPort=80,ToPort=80 # Delete the existing inbound rule from the security group to block all incoming IPv6-based traffic over port 80.
MY_SUBNET_ID=$(aws ec2 describe-instances --instance-id $MY_INSTANCE_ID --query 'Reservations[].Instances[0].SubnetId' --output text) # Get the ID of the subnet associated with the instance, and store it temporarily.
MY_NETWORK_ACL_ID=$(aws ec2 describe-network-acls --filters Name=association.subnet-id,Values=$MY_SUBNET_ID --query 'NetworkAcls[].Associations[0].NetworkAclId' --output text) # Get the ID of the network ACL associated with the subnet, and store it temporarily.
aws ec2 delete-network-acl-entry --network-acl-id $MY_NETWORK_ACL_ID --ingress --rule-number 10000 # Delete the existing inbound rule from the network ACL to block all IPv4-based traffic over port 80. Advanced users: if you originally created this rule with a different number, change this suggested rule number to match.
aws ec2 delete-network-acl-entry --network-acl-id $MY_NETWORK_ACL_ID --ingress --rule-number 10100 # Delete the existing inbound rule from the network ACL to block all IPv6-based traffic over port 80. Advanced users: if you originally created this rule with a different number, change this suggested rule number to match.
```
이 환경의 사용을 완료하면 AWS 계정에 계속 요금이 부과되지 않도록 환경을 삭제하세요. 지침은 [에서 환경 삭제 AWS Cloud9](delete-environment.md) 단원을 참조하세요.
# 에 대한 WordPress 자습서 AWS Cloud9
이 자습서를 사용하면 AWS Cloud9 개발 환경 내에서 WordPress를 설치하고 실행할 수 있습니다. WordPress는 전송 웹 콘텐츠에 널리 사용되는 오픈 소스 콘텐츠 관리 시스템(CMS)입니다.
**참고**
이 자습서를 따르고이 샘플을 생성하면 AWS 계정에 요금이 부과될 수 있습니다. 여기에는 Amazon Elastic Compute Cloud(Amazon EC2)와 같은 서비스에 대해 발생할 수 있는 요금이 포함됩니다. 자세한 내용은 [Amazon EC2 요금](https://aws.amazon.com/ec2/pricing/)을 참조하세요.
## 사전 조건
이 샘플을 사용하기 전에 설정이 다음 요구 사항을 충족하는지 확인하세요.
+ **기존 AWS Cloud9 EC2 개발 환경이 있어야 합니다.** 이 샘플에서는 Amazon Linux 또는 Ubuntu 서버를 실행 중인 Amazon EC2 인스턴스에 연결된 EC2 환경이 이미 있다고 가정합니다. 다른 환경 또는 운영 시스템이라면 이 샘플 지침을 관련 도구를 설치하는 데에 적용해야 합니다. 자세한 내용은 [에서 환경 생성 AWS Cloud9](create-environment.md) 단원을 참조하십시오.
+ **기존 환경의 AWS Cloud9 IDE가 이미 열려 있습니다.** 환경을 열면가 웹 브라우저에서 해당 환경의 IDE를 AWS Cloud9 엽니다. 자세한 내용은 [에서 환경 열기 AWS Cloud9](open-environment.md) 단원을 참조하십시오.
+ **최신 소프트웨어 패키지가 모두 포함된 최신 EC2 인스턴스가 있습니다**. IDE 터미널 창에서 확인을 요청하지 않고 업데이트를 설치하는 `-y` 옵션을 `yum update` 사용하여 AWS Cloud9 를 실행할 수 있습니다. 설치 전에 업데이트 정보를 확인하려면 이 옵션을 생략합니다.
```
sudo yum update -y
```
## 설치 개요
환경의 EC2 인스턴스에 WordPress를 설치하는 단계는 다음과 같습니다.
1. WordPress 설치에 대한 정보를 저장하는 오픈 소스 관계형 데이터베이스인 MariaDB 서버 설치 및 구성
1. `wordpress.conf` 구성 파일이 포함된 WordPress 설치 및 구성
1. WordPress 사이트를 호스트하는 Apache 서버 구성
1. Apache 서버에서 호스트하는 WordPress 웹 콘텐츠 미리 보기
## 1단계: MariaDB 서버 설치 및 구성
1. AWS Cloud9 IDE에서 **창**, **새 터미널**을 선택하고 다음 명령을 입력하여 MariaDB Server 설치를 설치하고 시작합니다.
```
sudo yum install -y mariadb-server
sudo systemctl start mariadb
```
1. 다음으로, `mysql_secure_installation` 스크립트를 실행하여 MariaDB 서버 설치의 보안을 강화합니다.
이 스크립트에 대한 응답을 제공할 때 첫 번째 질문에 대해 **Enter** 키를 입력하여 루트 암호를 비워 둡니다. `Set root password?`에 대해 **n** 키를 누른 다음 나머지 각 보안 옵션에 대해 **y** 키를 누릅니다.
```
mysql_secure_installation
```
1. 이제 MariaDB 클라이언트를 사용하여 WordPress 정보를 저장할 데이터베이스 테이블을 만듭니다.
(암호를 묻는 메시지가 나타나면 **Enter** 키를 누릅니다.)
```
sudo mysql -u root -p
MariaDB [(none)]> create database wp_test;
MariaDB [(none)]> grant all privileges on wp_test.* to root@localhost identified by ';'
```
1. MariaDB 클라이언트에서 로그아웃하려면 `exit` 명령을 실행합니다.
## 2단계: WordPress 설치 및 구성
1. IDE 터미널 창에서 `environment` 디렉터리로 이동한 다음 `config` 및 `wordpress` 디렉터리를 만듭니다. 그런 다음 `touch` 명령을 실행하여 `config` 디렉터리에 `wordpress.conf`라는 파일을 생성합니다.
```
cd /home/ec2-user/environment
mkdir config wordpress
touch config/wordpress.conf
```
1. IDE 편집기 또는 vim을 사용하여, Apache 서버가 WordPress 콘텐츠를 제공할 수 있도록 허용하는 호스트 구성 정보로 `wordpress.conf`를 업데이트합니다.
```
# Ensure that Apache listens on port 80
Listen 8080
DocumentRoot "/var/www/wordpress"
ServerName www.example.org
# Other directives here
```
1. 이제 다음 명령을 실행하여 필요한 아카이브 파일을 검색하고 WordPress를 설치합니다.
```
cd /home/ec2-user/environment
wget https://wordpress.org/latest.tar.gz
tar xvf latest.tar.gz
```
1. `touch` 명령을 실행하여 `environment/wordpress` 디렉터리에 `wp-config.php`라는 파일을 생성합니다.
```
touch wordpress/wp-config.php
```
1. IDE 편집기 또는 vim을 사용하여 `wp-config.php`로 업데이트한 다음 샘플 데이터를 설정으로 바꿉니다.
```
// ** MySQL settings - You can get this info from your web host ** //
/** The name of the database for WordPress */
define( 'DB_NAME', 'wp_test' );
/** MySQL database username */
define( 'DB_USER', 'wp_user' );
/** MySQL database password */
define( 'DB_PASSWORD', 'YourSecurePassword' );
/** MySQL hostname */
define( 'DB_HOST', 'localhost' );
/** Database Charset to use in creating database tables. */
define( 'DB_CHARSET', 'utf8' );
/** The Database Collate type. Don't change this if in doubt. */
define( 'DB_COLLATE', '' );
define('FORCE_SSL', true);
if ($_SERVER['HTTP_X_FORWARDED_PROTO'] == 'https') $_SERVER['HTTPS'] = 'on';
```
## 3 단계: Apache HTTP 서버 구성
1. AWS Cloud9 IDE 터미널 창에서 Apache가 설치되어 있는지 확인합니다.
```
httpd -v
```
Apache 서버가 설치되어 있지 않으면 다음 명령을 실행합니다.
```
sudo yum install -y httpd
```
1. `/etc/httpd/conf.d` 디렉터리로 이동합니다. 이 디렉터리는 Apache의 가상 호스트 구성 파일의 위치입니다. 그런 다음 `ln` 명령을 사용하여 앞서 생성한 `wordpress.conf`를 현재 작업 디렉터리(`/etc/httpd/conf.d`)에 연결합니다.
```
cd /etc/httpd/conf.d
sudo ln -s /home/ec2-user/environment/config/wordpress.conf
```
1. 이제 `/var/www` 디렉터리로 이동합니다. 이 디렉터리는 Apache 서버의 기본 루트 폴더입니다. 그리고 `ln` 명령을 사용하여 앞서 생성한 `wordpress` 디렉터리를 현재 작업 디렉터리(`/var/www`)에 연결합니다.
```
cd /var/www
sudo ln -s /home/ec2-user/environment/wordpress
```
1. `chmod` 명령을 실행하여 Apache 서버가 `wordpress` 하위 디렉터리의 톤텐츠를 실행하도록 허용합니다.
```
sudo chmod +x /home/ec2-user/
```
1. 이제 Apache 서버를 다시 시작하면 새 구성이 감지됩니다.
```
sudo service httpd restart
```
## 4 단계: WordPress 웹 콘텐츠 미리 보기
1. AWS Cloud9 IDE를 사용하여 디렉터리`index.html`에 라는 새 파일을 생성합니다`environment/wordpress`.
1. HTML 형식의 텍스트를 `index.html`에 추가합니다. 예제:
```
Hello World!
```
1. **환경** 창에서 `index.html` 파일을 선택한 다음 **미리 보기**, **실행 중인 애플리케이션 미리 보기**를 선택합니다.
*Hello World\$1* 메시지가 표시된 웹 페이지가 애플리케이션 미리 보기 탭에 나타납니다. 선호하는 브라우저에서 웹 콘텐츠를 보려면 [**새 창으로 팝업(Pop Out Into a New Window)**]을 선택합니다.
`index.html` 파일을 삭제하고 애플리케이션 미리 보기 탭을 새로 고치면 WordPress 구성 페이지가 표시됩니다.
## 혼합 컨텐츠 오류 관리
웹 브라우저는 HTTPS 및 HTTP 스크립트 또는 콘텐츠를 동시에 로드하는 경우 WordPress 사이트에 대해 혼합 콘텐츠 오류를 표시합니다. 오류 메시지의 표현은 사용 중인 웹 브라우저에 따라 다르지만 사이트에 대한 연결이 안전하지 않거나 완전하게 보안되지 않는다는 메시지가 표시됩니다. 또한 웹 브라우저가 혼합 콘텐츠에 대한 액세스를 차단합니다.
**중요**
기본적으로 AWS Cloud9 IDE의 애플리케이션 미리 보기 탭에서 액세스하는 모든 웹 페이지는 HTTPS 프로토콜을 자동으로 사용합니다. 페이지의 URI에 안전하지 않은 `http` 프로토콜이 있으면 자동으로 `https`로 대체됩니다. 그리고 수동으로 `https`를 다시 `http`로 변경하더라도 안전하지 않은 콘텐츠에 액세스할 수 없습니다.
웹 사이트에 대한 HTTPS를 구현하는 방법에 대한 지침은 [WordPress 문서](https://wordpress.org/support/article/https-for-wordpress/)를 참조하세요.
# 용 Java 자습서 AWS Cloud9
**중요**
2GiB 이상의 메모리가 있는 EC2 인스턴스에서 지원하는 AWS Cloud9 개발 환경을 사용하는 경우 향상된 Java 지원을 활성화하는 것이 좋습니다. 이를 통해 코드 완성, 오류에 대한 linting, 컨텍스트별 작업, 디버깅 옵션(예: 중단점 및 단계별 실행) 등의 생산성 기능에 액세스할 수 있습니다.
자세한 내용은 [Java 개발을 위한 향상된 지원](enhanced-java.md) 단원을 참조하십시오.
이 자습서를 사용하면 AWS Cloud9 개발 환경에서 일부 Java 코드를 실행할 수 있습니다.
이 자습서를 따르고 이 샘플을 생성하면 AWS 계정에 요금이 발생할 수 있습니다. 여기에는 Amazon EC2 및 Amazon S3 같은 서비스에 대한 발생할 수 있는 요금이 포함됩니다. 자세한 내용은 [Amazon EC2 요금](https://aws.amazon.com/ec2/pricing/) 및 [Amazon S3 요금](https://aws.amazon.com/s3/pricing/)을 참조하세요.
**Topics**
+ [사전 조건](#sample-java-prerequisites)
+ [1단계: 필수 도구 설치](#sample-java-install)
+ [2단계: 코드 추가](#sample-java-code)
+ [3단계: 코드 빌드 및 실행](#sample-java-run)
+ [4단계:를 사용하도록 설정 AWS SDK for Java](#sample-java-sdk)
+ [5단계: 환경에서 AWS 자격 증명 관리 설정](#sample-java-sdk-creds)
+ [6단계: AWS SDK 코드 추가](#sample-java-sdk-code)
+ [7단계: AWS SDK 코드 빌드 및 실행](#sample-java-sdk-run)
+ [8단계: 정리](#sample-java-clean-up)
## 사전 조건
이 샘플을 사용하기 전에 설정이 다음 요구 사항을 충족하는지 확인하세요.
+ **기존 AWS Cloud9 EC2 개발 환경이 있어야 합니다.** 이 샘플에서는 Amazon Linux 또는 Ubuntu 서버를 실행 중인 Amazon EC2 인스턴스에 연결된 EC2 환경이 이미 있다고 가정합니다. 다른 환경 또는 운영 시스템이라면 이 샘플 지침을 관련 도구를 설치하는 데에 적용해야 합니다. 자세한 내용은 [에서 환경 생성 AWS Cloud9](create-environment.md) 단원을 참조하십시오.
+ **기존 환경의 AWS Cloud9 IDE가 이미 열려 있습니다.** 환경을 열면가 웹 브라우저에서 해당 환경의 IDE를 AWS Cloud9 엽니다. 자세한 내용은 [에서 환경 열기 AWS Cloud9](open-environment.md) 단원을 참조하십시오.
## 1단계: 필수 도구 설치
이 단계에서는 개발 환경에 Java AWS Cloud9 개발 도구 세트를 설치합니다. Oracle JDK 또는 OpenJDK와 같은 Java 개발 도구 세트가 환경에 이미 설치되어 있는 경우 [2단계: 코드 추가](#sample-java-code) 섹션으로 진행합니다. 이 샘플은 OpenJDK 8에서 개발되었으며 다음 절차를 완료하여 사용자 환경에 설치할 수 있습니다.
1. OpenJDK 8이 이미 설치되었는지 확인합니다. 이렇게 하려면 AWS Cloud9 IDE의 터미널 세션에서 ** `-version` ** 옵션을 사용하여 Java 실행기의 명령줄 버전을 실행합니다. (터미널 세션을 새로 시작하려면 메뉴 모음에서 **Window(창)**, **New Terminal(새 터미널)**을 선택합니다.)
```
java -version
```
이전 명령의 출력을 기준으로 다음 중 하나를 수행합니다.
+ 출력에 `java` 명령을 찾을 수 없다고 표시될 경우 이 절차의 2단계를 진행하여 OpenJDK 8을 설치합니다.
+ 출력에 `Java(TM)`, `Java Runtime Environment`, `Java SE`, `J2SE` 또는 `Java2`로 시작하는 값이 포함되어 있는 경우, OpenJDK가 설치되지 않았거나 기본 Java 개발 도구 세트로 설정되지 않은 것입니다. 이 절차의 2단계를 계속 진행하여 OpenJDK 8을 설치한 다음 OpenJDK 8을 사용하도록 전환합니다.
+ 출력에 `java version 1.8` 및 `OpenJDK`로 시작하는 값이 포함되어 있는 경우 [2단계: 코드 추가](#sample-java-code) 섹션으로 건너뜁니다. 이 샘플에 대해 OpenJDK 8이 올바르게 설치되어 있습니다.
+ 출력에 `1.8`보다 이전 `java version`과 `OpenJDK`로 시작하는 값이 포함되어 있는 경우 이 절차의 2단계를 계속 진행하여 설치된 OpenJDK 버전을 OpenJDK 8로 업그레이드합니다.
1. 최신 보안 업데이트 및 버그 수정 사항이 설치되었는지 확인합니다. 이렇게 하려면** `update` **명령을 사용하여 yum 도구(Amazon Linux) 또는 apt 도구(Ubuntu Server)를 실행합니다.
Amazon Linux의 경우:
```
sudo yum -y update
```
Ubuntu Server:
```
sudo apt update
```
1. OpenJDK 8울 설치합니다. 이렇게 하려면 OpenJDK 8 패키지를 지정하고** `install` **명령을 사용하여 yum 도구(Amazon Linux) 또는 apt 도구(Ubuntu Server)를 실행합니다.
Amazon Linux의 경우:
```
sudo yum -y install java-1.8.0-openjdk-devel
```
Ubuntu Server:
```
sudo apt install -y openjdk-8-jdk
```
자세한 내용은 OpenJDK 웹 사이트에서 [OpenJDK 패키지 다운로드 및 설치 방법](https://openjdk.org/install/)을 참조하세요.
1. 기본 Java 개발 도구 세트를 OpenJDK 8로 전환하거나 업그레이드합니다. 이렇게 하려면** `--config` **옵션을 사용하여** `update-alternatives` **명령을 실행합니다. Java 러너 및 컴파일러의 명령줄 버전을 전환하거나 업그레이드하려면 이 명령을 두 번 실행합니다.
```
sudo update-alternatives --config java
sudo update-alternatives --config javac
```
각 프롬프트에서 OpenJDK 8의 선택 번호(`java-1.8`이 포함된 번호)를 입력합니다.
1. Java 러너 및 컴파일러의 명령줄 버전이 OpenJDK 8을 사용하고 있는지 확인합니다. 이렇게 하려면 `-version` 옵션을 사용하여 Java 러너 및 컴파일러의 명령줄 버전을 실행합니다.
```
java -version
javac -version
```
OpenJDK 8이 올바르게 설치되고 설정된 경우, Java 러너 버전 출력에 `openjdk version 1.8`로 시작하는 값이 포함되며, Java 컴파일러 버전 출력이 `javac 1.8`이라는 값으로 시작됩니다.
## 2단계: 코드 추가
AWS Cloud9 IDE에서 다음 코드가 포함된 파일을 생성하고 이름이 인 파일을 저장합니다`hello.java`. (파일을 생성하려면 메뉴 모음에서 [**파일(File)**], [**새 파일(New File)**]을 선택합니다. 파일을 저장하려면 [**파일(File)**], [**저장(Save)**]을 선택합니다.)
```
public class hello {
public static void main(String []args) {
System.out.println("Hello, World!");
System.out.println("The sum of 2 and 3 is 5.");
int sum = Integer.parseInt(args[0]) + Integer.parseInt(args[1]);
System.out.format("The sum of %s and %s is %s.\n",
args[0], args[1], Integer.toString(sum));
}
}
```
## 3단계: 코드 빌드 및 실행
1. Java 컴파일러의 명령줄 버전을 사용하여 `hello.java` 파일을 `hello.class` 파일로 컴파일합니다. 이렇게 AWS Cloud9 하려면 IDE의 터미널을 사용하여 `hello.java` 파일과 동일한 디렉터리에서 Java 컴파일러를 실행하고 `hello.java` 파일을 지정합니다.
```
javac hello.java
```
1. Java 러너의 명령줄 버전을 사용하여 `hello.class` 파일을 실행합니다. 이렇게 하려면 `hello.class` 파일과 동일한 디렉터리에서 `hello.java` 파일에 선언된 `hello` 클래스의 이름과 추가할 두 개의 정수(예: `5` 및 `9`)를 지정하여 Java 러너를 실행합니다.
```
java hello 5 9
```
1. 출력을 비교합니다.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## 4단계:를 사용하도록 설정 AWS SDK for Java
이 샘플을 개선하여 AWS SDK for Java 를 사용하여 Amazon S3 버킷을 생성하고 사용 가능한 버킷을 나열한 다음 방금 생성한 버킷을 삭제할 수 있습니다.
이 단계에서는 환경에 [Apache Maven](https://maven.apache.org/) 또는 [Gradle](https://gradle.org/)을 설치합니다. Maven과 Gradle은 Java 프로젝트에 사용할 수 있는 일반적인 빌드 자동화 시스템입니다. Maven 또는 Gradle을 설치한 후, 새로운 Java 프로젝트를 생성하는 데 사용합니다. 이 새 프로젝트에서는 AWS SDK for Java에 대한 참조를 추가합니다. 이렇게 AWS SDK for Java 하면 Java 코드에서 Amazon S3와 같은 AWS 서비스와 편리하게 상호 작용할 수 있습니다.
**Topics**
+ [Maven 설정](#sample-java-sdk-maven)
+ [Gradle을 사용하여 설정](#sample-java-sdk-gradle)
### Maven 설정
1. 환경에 Maven을 설치합니다. AWS Cloud9 IDE의 터미널을 사용하여 Maven이 이미 설치되어 있는지 확인하려면 ** `-version` ** 옵션과 함께 Maven을 실행합니다.
```
mvn -version
```
성공할 경우, 출력에 Maven 버전 번호가 포함됩니다. Maven이 이미 설치되어 있는 경우 이 절차의 4단계로 건너뛰어 Maven을 사용하여 환경에서 새 Java 프로젝트를 생성합니다.
1. 다음 명령을 실행하는 터미널을 사용하여 Maven을 설치합니다.
Amazon Linux의 경우, 다음 명령은 Maven이 저장되어 있는 패키지 리포지토리에 대한 정보를 가져오고 이 정보를 사용하여 Maven을 설치합니다.
```
sudo wget http://repos.fedorapeople.org/repos/dchen/apache-maven/epel-apache-maven.repo -O /etc/yum.repos.d/epel-apache-maven.repo
sudo sed -i s/\$releasever/6/g /etc/yum.repos.d/epel-apache-maven.repo
sudo yum install -y apache-maven
```
앞의 명령에 대한 자세한 내용은 Fedora Project Wiki 웹 사이트에서 [Extra Packages for Enterprise Linux(EPEL)](https://docs.fedoraproject.org/en-US/epel/)를 참조하세요.
Ubuntu Server의 경우 다음 명령을 대신 실행합니다.
```
sudo apt install -y maven
```
1. **`-version` **옵션을 지정하고 Maven을 실행하여 설치를 확인합니다.
```
mvn -version
```
1. Maven을 사용하여 새 Java 프로젝트를 생성합니다. 이렇게 하려면 터미널을 사용하여, Maven이 프로젝트를 생성하도록 하려는 디렉터리(예: 환경의 루트 디렉터리)에서 다음 명령을 실행합니다.
```
mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
```
앞의 명령은 사용자 환경에서 프로젝트에 대해 다음과 같은 디렉터리 구조를 생성합니다.
```
my-app
|- src
| `- main
| `- java
| `- com
| `- mycompany
| `- app
| `-App.java
|- test
| `- java
| `- com
| `- mycompany
| `- app
| `- AppTest.java
`- pom.xml
```
앞의 디렉터리 구조에 대한 자세한 내용은 Apache Maven Project 웹 사이트에서 [Maven Quickstart Archetype](https://maven.apache.org/archetypes/maven-archetype-quickstart/) 및 [표준 디렉터리 레이아웃 소개](https://maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html)를 참조하세요.
1. 프로젝트의 Project Object Model(POM) 파일을 수정합니다. (POM 파일은 Maven 프로젝트의 설정을 정의합니다.) 이렇게 하려면 [**환경(Environment)**] 창에서 `my-app/pom.xml` 파일을 엽니다. 편집기에서 이 파일의 현재 내용을 다음 코드로 바꾼 다음 `pom.xml` 파일을 저장합니다.
```
4.0.0
com.mycompany.app
my-app
jar
1.0-SNAPSHOT
org.apache.maven.plugins
maven-assembly-plugin
3.6.0
jar-with-dependencies
com.mycompany.app.App
package
single
junit
junit
3.8.1
test
com.amazonaws
aws-java-sdk
1.11.330
```
앞의 POM 파일에는 다음과 같은 선언을 지정하는 프로젝트 설정이 포함되어 있습니다.
+ `my-app`의 `artifactid` 설정은 프로젝트의 루트 디렉터리 이름을 설정하고, `com.mycompany.app`의 `group-id` 설정은 `com/mycompany/app` 하위 디렉터리 구조와 `App.Java` 및 `AppTest.java` 파일의 `package`선언을 설정합니다.
+ `my-app`의 `artifactId` 설정은 `jar`의 `packaging` 설정, `1.0-SNAPSHOT`의 `version` 설정, 그리고 `jar-with-dependencies`의 `descriptorRef` 설정과 함께 출력 JAR 파일의 이름(`my-app-1.0-SNAPSHOT-jar-with-dependencies.jar`)을 설정합니다.
+ `plugin` 섹션은 모든 종속성을 포함하는 단일 JAR이 빌드된다는 것을 선언합니다.
+ 의 `groupId` 설정`com.amazon.aws`과의 `artifactId` 설정이 있는 `dependency` 섹션에는 AWS SDK for Java 라이브러리 파일이 `aws-java-sdk` 포함되어 있습니다. 사용할 AWS SDK for Java 버전은 `version` 설정에 의해 선언됩니다. 다른 버전을 사용하려면 이 버전 번호를 바꿉니다.
[5단계: 환경에서 AWS 자격 증명 관리 설정](#sample-java-sdk-creds) 단원으로 이동합니다.
### Gradle을 사용하여 설정
1. 환경에 Gradle을 설치합니다. AWS Cloud9 IDE의 터미널을 사용하여 Gradle이 이미 설치되어 있는지 확인하려면 ** `-version` ** 옵션과 함께 Gradle을 실행합니다.
```
gradle -version
```
성공할 경우, 출력에 Gradle 버전 번호가 포함됩니다. Gradle이 이미 설치되어 있는 경우 이 절차의 4단계로 건너뛰어 Gradle을 사용하여 환경에서 새 Java 프로젝트를 생성합니다.
1. 다음 명령을 실행하는 터미널을 사용하여 Gradle을 설치합니다. 이 명령은 SDKMAN\$1 도구를 설치하고 실행한 다음, SDKMAN\$1을 사용하여 Gradle 최신 버전을 설치합니다.
```
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install gradle
```
앞의 명령에 대한 자세한 내용은 SDKMAN\$1 웹 사이트의 [설치](https://sdkman.io/install)와 Gradle 웹 사이트의 [패키지 관리자를 사용하여 설치](https://gradle.org/install/#with-a-package-manager)를 참조하세요.
1. **`-version` **옵션을 지정하고 Gradle을 실행하여 설치를 확인합니다.
```
gradle -version
```
1. Gradle을 사용하여 환경에서 새 Java 프로젝트를 생성합니다. 이렇게 하려면 터미널에서 다음 명령을 실행하여 프로젝트의 디렉터리를 생성한 다음 디렉터리로 전환합니다.
```
mkdir my-app
cd my-app
```
1. 다음 명령을 실행하여 Gradle이 환경의 `my-app` 디렉터리에 새 Java 애플리케이션 프로젝트를 생성하도록 합니다.
```
gradle init --type java-application
```
앞의 명령은 사용자 환경에서 프로젝트에 대해 다음과 같은 디렉터리 구조를 생성합니다.
```
my-app
|- .gradle
| `- (various supporting project folders and files)
|- gradle
| `- (various supporting project folders and files)
|- src
| |- main
| | `- java
| | `- App.java
| `- test
| `- java
| `- AppTest.java
|- build.gradle
|- gradlew
|- gradlew.bat
`- settings.gradle
```
1. 프로젝트의 `AppTest.java`를 수정합니다. (이렇게 하지 않으면 프로젝트가 정상적으로 빌드되거나 실행되지 않을 수 있습니다.) 이렇게 하려면 [**환경(Environment)**] 창에서 `my-app/src/test/java/AppTest.java` 파일을 엽니다. 편집기에서 이 파일의 현재 내용을 다음 코드로 바꾼 다음 `AppTest.java` 파일을 저장합니다.
```
import org.junit.Test;
import static org.junit.Assert.*;
public class AppTest {
@Test public void testAppExists () {
try {
Class.forName("com.mycompany.app.App");
} catch (ClassNotFoundException e) {
fail("Should have a class named App.");
}
}
}
```
1. 프로젝트의 `build.gradle` 파일을 수정합니다. (`build.gradle` 파일은 Gradle 프로젝트의 설정을 정의합니다.) 이렇게 하려면 [**환경(Environment)**] 창에서 `my-app/build.gradle` 파일을 엽니다. 편집기에서 이 파일의 현재 내용을 다음 코드로 바꾼 다음 `build.gradle` 파일을 저장합니다.
```
apply plugin: 'java'
apply plugin: 'application'
repositories {
jcenter()
mavenCentral()
}
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath "io.spring.gradle:dependency-management-plugin:1.0.3.RELEASE"
}
}
apply plugin: "io.spring.dependency-management"
dependencyManagement {
imports {
mavenBom 'com.amazonaws:aws-java-sdk-bom:1.11.330'
}
}
dependencies {
compile 'com.amazonaws:aws-java-sdk-s3'
testCompile group: 'junit', name: 'junit', version: '4.12'
}
run {
if (project.hasProperty("appArgs")) {
args Eval.me(appArgs)
}
}
mainClassName = 'App'
```
앞의 `build.gradle` 파일에는 다음과 같은 선언을 지정하는 프로젝트 설정이 포함되어 있습니다.
+ `io.spring.dependency-management` 플러그인은 프로젝트의 AWS SDK for Java 종속성을 관리하기 위해 AWS SDK for Java Maven BOM(Bill of Materials)을 가져오는 데 사용됩니다.는 사용할 버전을 `classpath` 선언합니다. 다른 버전을 사용하려면 이 버전 번호를 바꿉니다.
+ `com.amazonaws:aws-java-sdk-s3`는 AWS SDK for Java 라이브러리 파일의 Amazon S3 부분을 포함합니다. `mavenBom`은 사용할 버전을 선언합니다. 다른 버전을 사용하려면 이 버전 번호를 바꿉니다.
## 5단계: 환경에서 AWS 자격 증명 관리 설정
를 사용하여 AWS 서비스를 호출 AWS SDK for Java 할 때마다 호출과 함께 자격 증명 세트를 AWS 제공해야 합니다. 이러한 자격 증명은에 해당 호출을 수행할 수 AWS SDK for Java 있는 적절한 권한이 있는지 여부를 결정합니다. 자격 증명으로 적절한 권한이 확인되지 않는 경우 호출이 실패합니다.
이 단계에서는 환경 내에서 자격 증명을 저장합니다. 이렇게 하려면 [AWS 서비스 의 환경에서 호출 AWS Cloud9](credentials.md) 섹션의 지침을 수행한 다음 이 주제로 돌아옵니다.
자세한 내용은 *AWS SDK for Java 개발자 안내서*에서 [개발을 위한 AWS 자격 증명 및 리전 설정](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html#setup-credentials)을 참조하세요.
## 6단계: AWS SDK 코드 추가
이 단계에서는 코드를 추가하여 Amazon S3와 상호 작용하고, 버킷을 생성하고, 사용 가능한 버킷을 나열한 다음 막 생성한 버킷을 삭제합니다.
[**환경(Environment)**] 창에서 Maven의 경우 `my-app/src/main/java/com/mycompany/app/App.java` 파일 또는 Gradle의 경우 `my-app/src/main/java/App.java` 파일을 엽니다. 편집기에서 이 파일의 현재 내용을 다음 코드로 바꾼 다음 `App.java` 파일을 저장합니다.
```
package com.mycompany.app;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.AmazonS3Exception;
import com.amazonaws.services.s3.model.Bucket;
import com.amazonaws.services.s3.model.CreateBucketRequest;
import java.util.List;
public class App {
private static AmazonS3 s3;
public static void main(String[] args) {
if (args.length < 2) {
System.out.format("Usage: \n" +
"Example: my-test-bucket us-east-2\n");
return;
}
String bucket_name = args[0];
String region = args[1];
s3 = AmazonS3ClientBuilder.standard()
.withCredentials(new ProfileCredentialsProvider())
.withRegion(region)
.build();
// List current buckets.
ListMyBuckets();
// Create the bucket.
if (s3.doesBucketExistV2(bucket_name)) {
System.out.format("\nCannot create the bucket. \n" +
"A bucket named '%s' already exists.", bucket_name);
return;
} else {
try {
System.out.format("\nCreating a new bucket named '%s'...\n\n", bucket_name);
s3.createBucket(new CreateBucketRequest(bucket_name, region));
} catch (AmazonS3Exception e) {
System.err.println(e.getErrorMessage());
}
}
// Confirm that the bucket was created.
ListMyBuckets();
// Delete the bucket.
try {
System.out.format("\nDeleting the bucket named '%s'...\n\n", bucket_name);
s3.deleteBucket(bucket_name);
} catch (AmazonS3Exception e) {
System.err.println(e.getErrorMessage());
}
// Confirm that the bucket was deleted.
ListMyBuckets();
}
private static void ListMyBuckets() {
List buckets = s3.listBuckets();
System.out.println("My buckets now are:");
for (Bucket b : buckets) {
System.out.println(b.getName());
}
}
}
```
## 7단계: AWS SDK 코드 빌드 및 실행
이전 단계의 코드를 실행하려면 터미널에서 다음 명령을 실행합니다. 이 명령은 Maven 또는 Gradle을 사용하여 프로젝트의 JAR 실행 파일을 만든 다음 Java 러너를 사용하여JAR을 실행합니다. JAR은 Amazon S3에서 생성할 버킷의 이름(예: `my-test-bucket`)과에서 버킷을 입력으로 생성할 AWS 리전의 ID(예: )로 실행됩니다`us-east-2`.
Maven의 경우 다음 명령을 실행합니다.
```
cd my-app
mvn package
java -cp target/my-app-1.0-SNAPSHOT-jar-with-dependencies.jar com.mycompany.app.App my-test-bucket us-east-2
```
Gradle의 경우 다음 명령을 실행합니다.
```
gradle build
gradle run -PappArgs="['my-test-bucket', 'us-east-2']"
```
결과를 다음 출력과 비교합니다.
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## 8단계: 정리
이 샘플 사용을 완료한 후 AWS 계정에 지속적인 요금이 부과되지 않도록 하려면 환경을 삭제해야 합니다. 지침은 [에서 환경 삭제 AWS Cloud9](delete-environment.md) 단원을 참조하세요.
# 에 대한 C\$1\$1 자습서 AWS Cloud9
이 자습서를 사용하면 AWS Cloud9 개발 환경에서 C\$1\$1 코드를 실행할 수 있습니다. 이 코드는 Amazon Web Services에 연결하는 데 사용할 수 있는 모듈화된 플랫폼 간 오픈 소스 라이브러리인 [AWS SDK for C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/welcome.html)에서 제공되는 리소스도 사용합니다.
이 자습서를 따르고이 샘플을 생성하면 AWS 계정에 요금이 부과될 수 있습니다. 여기에는 Amazon EC2 및 Amazon S3 같은 서비스에 대한 발생할 수 있는 요금이 포함됩니다. 자세한 내용은 [Amazon EC2 요금](https://aws.amazon.com/ec2/pricing/) 및 [Amazon S3 요금](https://aws.amazon.com/s3/pricing/)을 참조하세요.
**Topics**
+ [사전 조건](#sample-cplusplus-prereqs)
+ [1단계: g\$1\$1 및 필요한 개발 패키지 설치](#sample-cplusplus-install)
+ [2단계: CMake 설치](#install-cmake)
+ [3단계: SDK for C\$1\$1 가져오기 및 빌드](#install-cmake)
+ [4단계: C\$1\$1 및 CMakeLists 파일 생성](#sample-cplusplus-sdk-code)
+ [5단계: C\$1\$1 코드 빌드 및 실행](#build-and-run-cpp)
+ [6단계: 정리](#sample-cplusplus-clean-up)
## 사전 조건
이 샘플을 사용하기 전에 설정이 다음 요구 사항을 충족하는지 확인하세요.
+ **기존 AWS Cloud9 EC2 개발 환경이 있어야 합니다.** 이 샘플에서는 Amazon Linux 또는 Ubuntu 서버를 실행 중인 Amazon EC2 인스턴스에 연결된 EC2 환경이 이미 있다고 가정합니다. 다른 환경 또는 운영 시스템이라면 이 샘플 지침을 관련 도구를 설치하는 데에 적용해야 합니다. 자세한 내용은 [에서 환경 생성 AWS Cloud9](create-environment.md) 단원을 참조하십시오.
+ **기존 환경의 AWS Cloud9 IDE가 이미 열려 있습니다.** 환경을 열면가 웹 브라우저에서 해당 환경의 IDE를 AWS Cloud9 엽니다. 자세한 내용은 [에서 환경 열기 AWS Cloud9](open-environment.md) 단원을 참조하십시오.
## 1단계: g\$1\$1 및 필요한 개발 패키지 설치
C\$1\$1 애플리케이션을 빌드하고 실행하려면 [GNU Complier Collection(GCC)](https://gcc.gnu.org/)에서 제공하는 C\$1\$1 컴파일러인 `g++` 같은 유틸리티가 필요합니다.
또한 `libcurl`, `libopenssl`, `libuuid`, `zlib`용 헤더 파일(`-dev` 패키지)과 선택적으로 Amazon Polly 지원을 위한 `libpulse`도 필요합니다.
개발 도구를 설치하는 프로세스는 Amazon Linux/Amazon Linux 2 인스턴스를 사용하는지 아니면 Ubuntu 인스턴스를 사용하는지에 따라 약간 다릅니다.
------
#### [ Amazon Linux-based systems ]
AWS Cloud9 터미널에서 다음 명령을 실행하여를 이미 `gcc` 설치했는지 확인할 수 있습니다.
```
g++ --version
```
`g++`가 설치되어 있지 않은 경우 ‘Development Tools’라는 패키지 그룹의 일부로 손쉽게 설치할 수 있습니다. 이러한 도구는 `yum groupinstall` 명령을 사용하여 인스턴스에 추가됩니다.
```
sudo yum groupinstall "Development Tools"
```
`g++ --version`을 다시 실행하여 컴파일러가 설치되었는지 확인합니다.
이제 시스템의 패키지 관리자를 사용하여 필요한 라이브러리의 패키지를 설치합니다.
```
sudo yum install libcurl-devel openssl-devel libuuid-devel pulseaudio-libs-devel
```
------
#### [ Ubuntu-based systems ]
AWS Cloud9 터미널에서 다음 명령을 실행하여를 이미 `gcc` 설치했는지 확인할 수 있습니다.
```
g++ --version
```
gcc가 설치되어 있지 않은 경우, 다음 명령을 실행하여 Ubuntu 기반 시스템에 설치할 수 있습니다.
```
sudo apt update
sudo apt install build-essential
sudo apt-get install manpages-dev
```
`g++ --version`을 다시 실행하여 컴파일러가 설치되었는지 확인합니다.
이제 시스템의 패키지 관리자를 사용하여 필요한 라이브러리의 패키지를 설치합니다.
```
sudo apt-get install libcurl4-openssl-dev libssl-dev uuid-dev zlib1g-dev libpulse-dev
```
------
## 2단계: CMake 설치
소스 코드에서 실행 파일을 작성하는 프로세스를 자동화하는 `cmake` 도구를 설치해야 합니다.
1. IDE 터미널 창에서 다음 명령을 실행하여 필요한 아카이브를 가져옵니다.
```
wget https://cmake.org/files/v3.18/cmake-3.18.0.tar.gz
```
1. 아카이브에서 파일을 추출하고 압축을 푼 파일이 포함된 디렉터리로 이동합니다.
```
tar xzf cmake-3.18.0.tar.gz
cd cmake-3.18.0
```
1. 그런 다음 부트 스트랩 스크립트를 실행하고 다음 명령을 실행하여 `cmake`를 설치합니다.
```
./bootstrap
make
sudo make install
```
1. 다음 명령을 실행하여 도구를 설치했는지 확인합니다.
```
cmake --version
```
## 3단계: SDK for C\$1\$1 가져오기 및 빌드
AWS SDK for C\$1\$1를 설정하려면 소스에서 직접 SDK를 빌드하거나 패키지 관리자를 사용하여 라이브러리를 다운로드할 수 있습니다. 사용 가능한 옵션에 대한 자세한 내용은 *AWS SDK for C\$1\$1 개발자 안내서*의 [C\$1\$1용 AWS SDK 사용 시작하기](https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/getting-started.html)에서 확인할 수 있습니다.
이 샘플에서는 `git`를 사용하여 SDK 소스 코드를 복제하고 `cmake` SDK for C\$1\$1를 빌드하는 방법을 보여줍니다.
1. 터미널에서 다음 명령을 실행하여 원격 리포지토리를 복제하고 AWS Cloud9 환경의 모든 git 하위 모듈을 재귀적으로 가져옵니다.
```
git clone --recurse-submodules https://github.com/aws/aws-sdk-cpp
```
1. 새 `aws-sdk-cpp` 디렉터리로 이동하여 C\$1\$1용 AWS SDK를 빌드할 하위 디렉터리를 생성한 다음 해당 디렉터리로 이동합니다.
```
cd aws-sdk-cpp
mkdir sdk_build
cd sdk_build
```
1.
**참고**
시간을 절약하기 위해 이 단계에서는 AWS SDK for C\$1\$1의 Amazon S3 부분만 빌드합니다. 전체 SDK를 빌드하려면 `cmake` 명령에서 `-DBUILD_ONLY=s3`를 생략하세요.
전체 SDK for C\$1\$1를 구축하는 데에는 Amazon EC2 인스턴스 또는 자체 서버에서 사용할 수 있는 컴퓨팅 리소스에 따라 1시간 이상 걸릴 수 있습니다.
다음 명령을 실행함으로써 `cmake`를 사용하여 SDK for C\$1\$1의 Amazon S3 부분을 `sdk_build` 디렉터리에 빌드합니다.
```
cmake .. -DBUILD_ONLY=s3
```
1. 이제 빌드된 SDK에 액세스할 수 있도록 `make install` 명령을 실행합니다.
```
sudo make install
cd ..
```
## 4단계: C\$1\$1 및 CMakeLists 파일 생성
이 단계에서는 프로젝트 사용자가 Amazon S3 버킷과 상호 작용할 수 있도록 하는 `C++` 파일을 생성합니다.
또한 `cmake`가 C\$1\$1 라이브러리를 빌드하는 데 사용하는 지침을 제공하는 `CMakeLists.txt` 파일을 생성합니다.
1. AWS Cloud9 IDE에서이 콘텐츠가 포함된 파일을 생성하고 환경의 루트(`/`)`s3-demo.cpp`에 이름이 인 파일을 저장합니다.
```
#include
#include
#include
#include
#include
#include
#include
// Look for a bucket among all currently available Amazon S3 buckets.
bool FindTheBucket(const Aws::S3::S3Client &s3Client,
const Aws::String &bucketName) {
Aws::S3::Model::ListBucketsOutcome outcome = s3Client.ListBuckets();
if (outcome.IsSuccess()) {
std::cout << "Looking for a bucket named '" << bucketName << "'..."
<< std::endl << std::endl;
Aws::Vector bucket_list =
outcome.GetResult().GetBuckets();
for (Aws::S3::Model::Bucket const &bucket: bucket_list) {
if (bucket.GetName() == bucketName) {
std::cout << "Found the bucket." << std::endl << std::endl;
return true;
}
}
std::cout << "Could not find the bucket." << std::endl << std::endl;
} else {
std::cerr << "listBuckets error: "
<< outcome.GetError().GetMessage() << std::endl;
}
return outcome.IsSuccess();
}
// Create an Amazon S3 bucket.
bool CreateTheBucket(const Aws::S3::S3Client &s3Client,
const Aws::String &bucketName,
const Aws::String ®ion) {
std::cout << "Creating a bucket named '"
<< bucketName << "'..." << std::endl << std::endl;
Aws::S3::Model::CreateBucketRequest request;
request.SetBucket(bucketName);
if (region != "us-east-1") {
Aws::S3::Model::CreateBucketConfiguration createBucketConfig;
createBucketConfig.SetLocationConstraint(
Aws::S3::Model::BucketLocationConstraintMapper::GetBucketLocationConstraintForName(
region));
request.SetCreateBucketConfiguration(createBucketConfig);
}
Aws::S3::Model::CreateBucketOutcome outcome =
s3Client.CreateBucket(request);
if (outcome.IsSuccess()) {
std::cout << "Bucket created." << std::endl << std::endl;
} else {
std::cerr << "createBucket error: "
<< outcome.GetError().GetMessage() << std::endl;
}
return outcome.IsSuccess();
}
// Delete an existing Amazon S3 bucket.
bool DeleteTheBucket(const Aws::S3::S3Client &s3Client,
const Aws::String &bucketName) {
std::cout << "Deleting the bucket named '"
<< bucketName << "'..." << std::endl << std::endl;
Aws::S3::Model::DeleteBucketRequest request;
request.SetBucket(bucketName);
Aws::S3::Model::DeleteBucketOutcome outcome =
s3Client.DeleteBucket(request);
if (outcome.IsSuccess()) {
std::cout << "Bucket deleted." << std::endl << std::endl;
} else {
std::cerr << "deleteBucket error: "
<< outcome.GetError().GetMessage() << std::endl;
}
return outcome.IsSuccess();
}
#ifndef EXCLUDE_MAIN_FUNCTION
// Create an S3 bucket and then delete it.
// Before and after creating the bucket, and again after deleting the bucket,
// try to determine whether that bucket still exists.
int main(int argc, char *argv[]) {
if (argc < 3) {
std::cout << "Usage: s3-demo " << std::endl
<< "Example: s3-demo my-bucket us-east-1" << std::endl;
return 1;
}
Aws::SDKOptions options;
Aws::InitAPI(options);
{
Aws::String bucketName = argv[1];
Aws::String region = argv[2];
Aws::Client::ClientConfiguration config;
config.region = region;
Aws::S3::S3Client s3Client(config);
if (!FindTheBucket(s3Client, bucketName)) {
return 1;
}
if (!CreateTheBucket(s3Client, bucketName, region)) {
return 1;
}
if (!FindTheBucket(s3Client, bucketName)) {
return 1;
}
if (!DeleteTheBucket(s3Client, bucketName)) {
return 1;
}
if (!FindTheBucket(s3Client, bucketName)) {
return 1;
}
}
Aws::ShutdownAPI(options);
return 0;
}
#endif // EXCLUDE_MAIN_FUNCTION
```
1. 이 콘텐츠를 포함하는 두 번째 파일을 생성하고, 이 파일을 환경의 루트(`/`)에 `CMakeLists.txt`라는 이름으로 저장합니다. 이 파일을 사용하면 코드를 실행 파일로 빌드할 수 있습니다.
```
# A minimal CMakeLists.txt file for the AWS SDK for C++.
# The minimum version of CMake that will work.
cmake_minimum_required(VERSION 2.8)
# The project name.
project(s3-demo)
# Locate the AWS SDK for C++ package.
set(AWSSDK_ROOT_DIR, "/usr/local/")
set(BUILD_SHARED_LIBS ON)
find_package(AWSSDK REQUIRED COMPONENTS s3)
# The executable name and its source files.
add_executable(s3-demo s3-demo.cpp)
# The libraries used by your executable.
target_link_libraries(s3-demo ${AWSSDK_LINK_LIBRARIES})
```
## 5단계: C\$1\$1 코드 빌드 및 실행
1. `s3-demo.cpp` 및 `CMakeLists.txt`를 저장한 환경의 루트 디렉터리에서 `cmake`를 실행하여 프로젝트를 빌드합니다.
```
cmake .
make
```
1. 이제 명령줄에서 프로그램을 실행할 수 있습니다. 다음 명령에서 `my-unique-bucket-name`을 Amazon S3 버킷의 고유 이름으로 바꾸고, 필요한 경우 `us-east-1`을 버킷을 생성하려는 다른 AWS 리전의 식별자로 바꿉니다.
```
./s3-demo my-unique-bucket-name us-east-1
```
프로그램이 제대로 실행되면 다음과 비슷한 출력이 반환됩니다.
```
Looking for a bucket named 'my-unique-bucket-name'...
Could not find the bucket.
Creating a bucket named 'my-unique-bucket-name'...
Bucket created.
Looking for a bucket named 'my-unique-bucket-name'...
Found the bucket.
Deleting the bucket named 'my-unique-bucket-name'...
Bucket deleted.
Looking for a bucket named 'my-unique-bucket-name'...
Could not find the bucket.
```
## 6단계: 정리
이 샘플을 완료한 후 AWS 계정에 지속적인 요금이 부과되지 않도록 하려면 환경을 삭제합니다. 지침은 [에서 환경 삭제 AWS Cloud9](delete-environment.md) 단원을 참조하세요.
# 에 대한 Python 자습서 AWS Cloud9
이 자습서에서는 AWS Cloud9 개발 환경에서 Python 코드를 실행하는 방법을 보여줍니다.
이 자습서를 따르면 AWS 계정에 요금이 부과될 수 있습니다. 여기에는 Amazon Elastic Compute Cloud(Amazon EC2) 및 Amazon Simple Storage Service(Amazon S3)와 같은 서비스에 대해 발생할 수 있는 요금이 포함됩니다. 자세한 내용은 [Amazon EC2 요금](https://aws.amazon.com/ec2/pricing/) 및 [Amazon S3 요금](https://aws.amazon.com/s3/pricing/)을 참조하세요.
**Topics**
+ [사전 조건](#sample-python-prereqs)
+ [1단계: Python 설치](#sample-python-install)
+ [2단계: 코드 추가](#sample-python-code)
+ [3단계: 코드 실행](#sample-python-run)
+ [4단계: 설치 및 구성 AWS SDK for Python (Boto3)](#sample-python-sdk)
+ [5단계: AWS SDK 코드 추가](#sample-python-sdk-code)
+ [6단계: AWS SDK 코드 실행](#sample-python-sdk-run)
+ [7단계: 정리](#sample-python-clean-up)
## 사전 조건
이 자습서를 사용하기 전에 다음 요구 사항을 충족하는지 확인하십시오.
+ ** AWS Cloud9 EC2 개발 환경이 있는 경우**
이 샘플에서는 Amazon Linux 또는 Ubuntu 서버를 실행 중인 Amazon EC2 인스턴스에 연결된 EC2 환경이 이미 있다고 가정합니다. 세부 정보는 [EC2 환경 생성](create-environment-main.md) 섹션을 참조하세요.
다른 유형의 환경 또는 운영 체제가 있다면 이 자습서의 지침을 적용해야 합니다.
+ **해당 환경에 대한 AWS Cloud9 IDE를 열었습니다.**
환경을 열면가 웹 브라우저에서 해당 환경의 IDE를 AWS Cloud9 엽니다. 세부 정보는 [에서 환경 열기 AWS Cloud9](open-environment.md) 섹션을 참조하세요.
## 1단계: Python 설치
1. AWS Cloud9 IDE의 터미널 세션에서 ** `python --version` ** 명령을 실행하여 Python이 이미 설치되어 있는지 확인합니다. (새 터미널 세션을 시작하려면 메뉴 모음에서 **창**, **New Terminal(새 터미널)**을 선택합니다.) Python이 설치된 경우 [2단계: 코드 추가](#sample-python-code) 섹션으로 건너뜁니다.
1. **`yum update`**(Amazon Linux) 또는 **`apt update`**(Ubuntu Server) 명령을 실행하여 최신 보안 업데이트와 버그 수정이 설치되어 있는지 확인합니다.
Amazon Linux의 경우:
```
sudo yum -y update
```
Ubuntu Server:
```
sudo apt update
```
1. **`install` **명령을 실행하여 Python을 설치합니다.
Amazon Linux의 경우:
```
sudo yum -y install python3
```
Ubuntu Server:
```
sudo apt-get install python3
```
## 2단계: 코드 추가
AWS Cloud9 IDE에서 다음 콘텐츠가 포함된 파일을 생성하고 이름이 인 파일을 저장합니다`hello.py`. (파일을 생성하려면 메뉴 모음에서 [**파일(File)**, [**새 파일(New File)**]을 선택합니다. 파일을 저장하려면 [**파일(File)**], [**저장(Save)**]을 선택합니다.)
```
import sys
print('Hello, World!')
print('The sum of 2 and 3 is 5.')
sum = int(sys.argv[1]) + int(sys.argv[2])
print('The sum of {0} and {1} is {2}.'.format(sys.argv[1], sys.argv[2], sum))
```
## 3단계: 코드 실행
1. AWS Cloud9 IDE의 메뉴 모음에서 **실행**, **실행 구성**, **새 실행 구성을** 선택합니다.
1. [**[새로 만들기] - 중지됨([New] - Stopped)**] 탭에서 [**명령(Command**]에 `hello.py 5 9`를 입력합니다. 이 코드에서 `5`는 `sys.argv[1]`을 나타내고 `9`는 `sys.argv[2]`를 나타냅니다.
1. **실행**을 선택하여 출력을 비교합니다.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
1. 기본적으로는 코드에 대한 실행기를 AWS Cloud9 자동으로 선택합니다. 실행기를 변경하려면 **Runner(실행기)**를 선택한 다음 **Python 2** 또는 **Python 3**을 선택합니다.
**참고**
특정 버전의 Python에 대한 사용자 지정 실행기를 만들 수 있습니다. 자세한 내용은 [빌더 또는 러너 생성](build-run-debug.md#build-run-debug-create-builder-runner)을 참조하세요.
## 4단계: 설치 및 구성 AWS SDK for Python (Boto3)
AWS SDK for Python (Boto3) 를 사용하면 Python 코드를 사용하여 Amazon S3와 같은 AWS 서비스와 상호 작용할 수 있습니다. 예를 들어 SDK를 사용하여 Amazon S3 버킷을 생성하고 사용 가능한 버킷을 나열한 다음 방금 생성한 버킷을 삭제할 수 있습니다.
### PIP 설치
AWS Cloud9 IDE에서 ** `python -m pip --version` ** 명령을 실행하여 `pip`가 활성 버전의 Python에 이미 설치되어 있는지 확인합니다. `pip`가 설치된 경우 다음 섹션으로 건너뜁니다.
`pip`를 설치하려면 다음 명령을 실행합니다. sudo는 사용자와 다른 환경에 있기 때문에 현재 별칭 버전과 다른 경우 사용할 Python 버전을 지정해야 합니다.
```
curl -O https://bootstrap.pypa.io/get-pip.py # Get the install script.
sudo python3 get-pip.py # Install pip for Python 3.
python -m pip --version # Verify pip is installed.
rm get-pip.py # Delete the install script.
```
자세한 내용은 `pip` 웹 사이트에서 [설치](https://pip.pypa.io/en/stable/installing/)를 참조하세요.
### 설치 AWS SDK for Python (Boto3)
를 설치한 후 ** `pip install` ** 명령을 실행 AWS SDK for Python (Boto3) 하여를 `pip`설치합니다.
```
sudo python3 -m pip install boto3 # Install boto3 for Python 3.
python -m pip show boto3 # Verify boto3 is installed for the current version of Python.
```
자세한 내용은 AWS SDK for Python (Boto3)의 [Quickstart](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html)(빠른 시작)에서 "설치" 섹션을 참조하세요.
### 환경에서 자격 증명 설정
를 사용하여 AWS 서비스를 호출 AWS SDK for Python (Boto3) 할 때마다 호출과 함께 자격 증명 세트를 제공해야 합니다. 이러한 자격 증명은 SDK에 호출을 수행하는 데 필요한 권한이 있는지 여부를 결정합니다. 자격 증명이 필요한 권한을 포함하지 않으면 호출이 실패합니다.
환경에 자격 증명을 저장하려면 [AWS 서비스 의 환경에서 호출 AWS Cloud9](credentials.md)의 지침을 따른 다음 이 주제로 돌아옵니다.
자세한 내용은 AWS SDK for Python (Boto3)에서 [자격 증명](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html)을 참조하세요.
## 5단계: AWS SDK 코드 추가
Amazon S3를 사용하는 코드를 추가하여 버킷을 생성하고, 사용 가능한 버킷을 나열하고, 방금 생성한 버킷을 선택적으로 삭제합니다.
AWS Cloud9 IDE에서 다음 콘텐츠가 포함된 파일을 생성하고 이름이 인 파일을 저장합니다`s3.py`.
```
import sys
import boto3
from botocore.exceptions import ClientError
def list_my_buckets(s3_resource):
print("Buckets:\n\t", *[b.name for b in s3_resource.buckets.all()], sep="\n\t")
def create_and_delete_my_bucket(s3_resource, bucket_name, keep_bucket):
list_my_buckets(s3_resource)
try:
print("\nCreating new bucket:", bucket_name)
bucket = s3_resource.create_bucket(
Bucket=bucket_name,
CreateBucketConfiguration={
"LocationConstraint": s3_resource.meta.client.meta.region_name
},
)
except ClientError as e:
print(
f"Couldn't create a bucket for the demo. Here's why: "
f"{e.response['Error']['Message']}"
)
raise
bucket.wait_until_exists()
list_my_buckets(s3_resource)
if not keep_bucket:
print("\nDeleting bucket:", bucket.name)
bucket.delete()
bucket.wait_until_not_exists()
list_my_buckets(s3_resource)
else:
print("\nKeeping bucket:", bucket.name)
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("bucket_name", help="The name of the bucket to create.")
parser.add_argument("region", help="The region in which to create your bucket.")
parser.add_argument(
"--keep_bucket",
help="Keeps the created bucket. When not "
"specified, the bucket is deleted "
"at the end of the demo.",
action="store_true",
)
args = parser.parse_args()
s3_resource = (
boto3.resource("s3", region_name=args.region)
if args.region
else boto3.resource("s3")
)
try:
create_and_delete_my_bucket(s3_resource, args.bucket_name, args.keep_bucket)
except ClientError:
print("Exiting the demo.")
if __name__ == "__main__":
main()
```
## 6단계: AWS SDK 코드 실행
1. 메뉴 표시줄에서 **실행**, **실행 구성**, **새 실행 구성**을 선택합니다.
1. **명령**에를 입력합니다. `s3.py my-test-bucket us-west-2`여기서 `my-test-bucket`는 생성할 버킷의 이름이고 `us-west-2`는 버킷이 생성된 AWS 리전의 ID입니다. 기본적으로 버킷은 스크립트가 종료되기 전에 삭제됩니다. 버킷을 유지하려면 명령에 `--keep_bucket`을 추가합니다. AWS 리전 IDs 목록은의 [Amazon Simple Storage Service 엔드포인트 및 할당량을 참조하세요](https://docs.aws.amazon.com/general/latest/gr/s3.html)*AWS 일반 참조*.
**참고**
Amazon S3 버킷 이름은 계정 AWS 뿐만 AWS아니라 여러 계정에서 고유해야 합니다.
1. **Run(실행)**을 선택하여 출력을 비교합니다.
```
Buckets:
a-pre-existing-bucket
Creating new bucket: my-test-bucket
Buckets:
a-pre-existing-bucket
my-test-bucket
Deleting bucket: my-test-bucket
Buckets:
a-pre-existing-bucket
```
## 7단계: 정리
이 자습서를 완료한 후 AWS 계정에 지속적인 요금이 부과되지 않도록 하려면 AWS Cloud9 환경을 삭제합니다. 지침은 [에서 환경 삭제 AWS Cloud9](delete-environment.md) 단원을 참조하세요.
# 에 대한 .NET 자습서 AWS Cloud9
이 자습서를 사용하면 AWS Cloud9 개발 환경에서 일부 .NET 코드를 실행할 수 있습니다.
이 자습서를 따르고이 샘플을 생성하면 AWS 계정에 요금이 부과될 수 있습니다. 여기에는 Amazon EC2 및 Amazon S3 같은 서비스에 대한 발생할 수 있는 요금이 포함됩니다. 자세한 내용은 [Amazon EC2 요금](https://aws.amazon.com/ec2/pricing/) 및 [Amazon S3 요금](https://aws.amazon.com/s3/pricing/)을 참조하세요.
**Topics**
+ [사전 조건](#sample-dotnetcore-prereqs)
+ [1단계: 필수 도구 설치](#sample-dotnetcore-setup)
+ [2단계(선택 사항): Lambda 함수에 대한 .NET CLI 확장 설치](#sample-dotnetcore-lambda)
+ [3단계: .NET 콘솔 애플리케이션 프로젝트 만들기](#sample-dotnetcore-app)
+ [4단계: 코드 추가](#sample-dotnetcore-code)
+ [5단계: 코드 빌드 및 실행](#sample-dotnetcore-run)
+ [6단계:를 사용하는 .NET 콘솔 애플리케이션 프로젝트 생성 및 설정 AWS SDK for .NET](#sample-dotnetcore-sdk)
+ [7단계: AWS SDK 코드 추가](#sample-dotnetcore-sdk-code)
+ [8단계: AWS SDK 코드 빌드 및 실행](#sample-dotnetcore-sdk-run)
+ [9단계: 정리](#sample-dotnetcore-clean-up)
## 사전 조건
이 샘플을 사용하기 전에 설정이 다음 요구 사항을 충족하는지 확인하세요.
+ **기존 AWS Cloud9 EC2 개발 환경이 있어야 합니다.** 이 샘플에서는 Amazon Linux 또는 Ubuntu 서버를 실행 중인 Amazon EC2 인스턴스에 연결된 EC2 환경이 이미 있다고 가정합니다. 다른 환경 또는 운영 시스템이라면 이 샘플 지침을 관련 도구를 설치하는 데에 적용해야 합니다. 자세한 내용은 [에서 환경 생성 AWS Cloud9](create-environment.md) 단원을 참조하십시오.
+ **기존 환경의 AWS Cloud9 IDE가 이미 열려 있습니다.** 환경을 열면가 웹 브라우저에서 해당 환경의 IDE를 AWS Cloud9 엽니다. 자세한 내용은 [에서 환경 열기 AWS Cloud9](open-environment.md) 단원을 참조하십시오.
## 1단계: 필수 도구 설치
이 단계에서는 이 샘플을 실행하는 데 필요한 .NET SDK를 환경에 설치합니다.
1. .NET SDK의 최신 버전이 환경에 이미 설치되었는지 여부를 확인합니다. 이렇게 하려면 AWS Cloud9 IDE의 터미널 세션에서 ** `--version` ** 옵션을 사용하여 .NET Core 명령줄 인터페이스(CLI)를 실행합니다.
```
dotnet --version
```
.NET 명령줄 도구 버전이 표시되고 버전이 2.0 이상이면 [3단계: .NET 콘솔 애플리케이션 프로젝트 만들기](#sample-dotnetcore-app) 단원으로 이동합니다. 버전이 2.0 미만이거나 `bash: dotnet: command not found`와 같은 오류가 표시되면 계속해서 .NET SDK를 설치합니다.
1. Amazon Linux의 경우 AWS Cloud9 IDE의 터미널 세션에서 다음 명령을 실행하여 최신 보안 업데이트 및 버그 수정이 설치되었는지 확인하고 .NET SDK에 필요한 `libunwind` 패키지를 설치합니다. (터미널 세션을 새로 시작하려면 메뉴 모음에서 **Window(창), New Terminal(새 터미널)**을 선택합니다.)
```
sudo yum -y update
sudo yum -y install libunwind
```
Ubuntu Server의 경우 AWS Cloud9 IDE의 터미널 세션에서 다음 명령을 실행하여 최신 보안 업데이트 및 버그 수정이 설치되었는지 확인합니다. (터미널 세션을 새로 시작하려면 메뉴 모음에서 **Window(창), New Terminal(새 터미널)**을 선택합니다.)
```
sudo apt -y update
```
1. 다음 명령을 실행하여 환경으로 .NET SDK 설치 프로그램을 다운로드합니다.
```
wget https://dot.net/v1/dotnet-install.sh
```
1. 다음 명령을 실행하여 현재 사용자가 설치 프로그램 스크립트 실행 파일을 생성합니다.
```
sudo chmod u=rx dotnet-install.sh
```
1. 다음 명령을 실행하여 .NET SDK를 다운로드해 설치하는 설치 프로그램 스크립트를 실행합니다.
```
./dotnet-install.sh -c Current
```
1. `PATH`에 .NET SDK를 추가합니다. 이렇게 하려면 환경에 대한 셸 프로필(예: `.bashrc` 파일)에서 다음과 같이 환경에 대한 `PATH` 변수에 `$HOME/.dotnet` 하위 디렉터리를 추가합니다.
1. **`vi` **명령을 사용하여 편집을 위해 `.bashrc` 파일을 엽니다.
```
vi ~/.bashrc
```
1. Amazon Linux의 경우 아래쪽 화살표 또는 `j` 키를 사용하여 `export PATH`로 시작하는 행으로 이동합니다.
Ubuntu Server의 경우 `G`를 입력하여 파일의 마지막 행으로 이동합니다.
1. 오른쪽 화살표 또는 `$` 키를 사용하여 해당 행의 끝으로 이동합니다.
1. `i` 키를 눌러서 삽입 모드로 전환합니다.`-- INSERT ---`가 표시 화면의 끝에 나타납니다.
1. Amazon Linux의 경우 `:$HOME/.dotnet`을 입력하여 `$HOME/.dotnet` 하위 디렉터리를** `PATH` **변수에 추가합니다. 반드시 콜론 문자(`:`)를 포함해야 합니다. 이제 이 행은 다음과 같습니다.
```
export PATH=$PATH:$HOME/.local/bin:$HOME/bin:$HOME/.dotnet
```
Ubuntu Server의 경우 오른쪽 화살표 키를 누르고 `Enter` 키를 두 번 누른 다음 파일 끝에 직접 다음 행을 입력합니다.
```
export PATH=$HOME/.dotnet:$PATH
```
1. 파일을 저장합니다. 이렇게 하려면 `Esc` 키를 누릅니다. 표시 화면 끝에서 `-- INSERT ---`가 사라집니다. (파일에 쓰고 나서 파일을 종료하기 위해 `:wq`를 입력하고 나서 `Enter`를 누릅니다.
1. `.bashrc` 파일을 소싱하여 .NET SDK를 로드합니다.
```
. ~/.bashrc
```
1. **`--help` **옵션을 지정한 상태로 .NET CLI를 실행하여 .NET SDK가 로드되었는지 확인합니다.
```
dotnet --help
```
성공하면 추가 사용법 정보와 함께 .NET SDK 버전 번호가 표시됩니다.
1. 환경에서 .NET SDK 설치 프로그램 스크립트를 더 이상 유지하지 않으려면 다음과 같이 해당 파일을 삭제할 수 있습니다.
```
rm dotnet-install.sh
```
## 2단계(선택 사항): Lambda 함수에 대한 .NET CLI 확장 설치
이 자습서에서는 필수는 아니지만 `Amazon.Lambda.Tools` 패키지를 설치하는 경우 .NET CLI를 사용하여 AWS Lambda 함수와 AWS Serverless Application Model 애플리케이션을 배포할 수 있습니다.
1. 이 패키지를 설치하려면 다음 명령을 실행합니다.
```
dotnet tool install -g Amazon.Lambda.Tools
```
1. 이제 설치된 Lambda 도구를 가리키도록 `PATH` 및 `DOTNET_ROOT` 환경 변수를 설정합니다. `.bashrc` 파일에서 `export PATH` 섹션을 찾아 다음과 같이 표시되도록 편집합니다(이 파일 편집에 대한 자세한 내용은 1단계 참조).
```
export PATH=$PATH:$HOME/.local/bin:$HOME/bin:$HOME/.dotnet:$HOME/.dotnet/tools
export DOTNET_ROOT=$HOME/.dotnet
```
## 3단계: .NET 콘솔 애플리케이션 프로젝트 만들기
이 단계에서는 .NET을 사용하여 `hello` 프로젝트를 생성합니다. 이 프로젝트에는 IDE의 터미널에서 단순 애플리케이션을 실행하기 위해 .NET에 필요한 모든 파일이 포함되어 있습니다. 애플리케이션의 코드는 C\$1으로 작성되었습니다.
.NET 콘솔 애플리케이션 프로젝트를 생성합니다. 이렇게 하려면 사용할 콘솔 애플리케이션 프로젝트 템플릿 유형 및 프로그래밍 언어(이 샘플에서는 C\$1)를 지정하여 **`new`** 명령과 함께 .NET CLI를 실행합니다.
`-n` 옵션은 프로젝트가 `hello`라는 새 디렉터리로 출력됨을 나타냅니다. 그런 다음 해당 디렉터리로 이동합니다.
```
dotnet new console -lang C# -n hello
cd hello
```
이전 명령은 여러 파일을 포함하는 `obj` 하위 디렉터리와 추가 독립 실행형 파일을 `hello` 디렉터리에 추가합니다. 다음 키 파일 두 개에 유의해야 합니다.
+ `hello/hello.csproj` 파일에는 콘솔 애플리케이션 프로젝트에 대한 정보가 들어 있습니다.
+ `hello/Program.cs` 파일에는 실행할 애플리케이션의 코드가 들어 있습니다.
## 4단계: 코드 추가
이 단계에서는 애플리케이션에 코드를 추가합니다.
AWS Cloud9 IDE의 **환경** 창에서 `hello/Program.cs` 파일을 엽니다.
편집기에서 이 파일의 현재 내용을 다음 코드로 바꾼 다음 `Program.cs` 파일을 저장합니다.
```
using System;
namespace hello
{
class Program
{
static void Main(string[] args)
{
if (args.Length < 2) {
Console.WriteLine("Please provide 2 numbers");
return;
}
Console.WriteLine("Hello, World!");
Console.WriteLine("The sum of 2 and 3 is 5.");
int sum = Int32.Parse(args[0]) + Int32.Parse(args[1]);
Console.WriteLine("The sum of {0} and {1} is {2}.",
args[0], args[1], sum);
}
}
}
```
## 5단계: 코드 빌드 및 실행
이 단계에서는 프로젝트 및 관련 종속 항목을 바이너리 파일 세트(실행 가능한 애플리케이션 파일 포함)로 빌드합니다. 그런 다음 애플리케이션을 실행합니다.
1. IDE에서 다음과 같이 .NET용 빌더를 생성합니다.
1. 메뉴 모음에서 **Run, Build System, New Build System(실행, 빌드 시스템, 새 빌드 시스템)**을 선택합니다.
1. **My Builder.build** 탭에서 탭의 내용을 다음 코드로 바꿉니다.
```
{
"cmd" : ["dotnet", "build"],
"info" : "Building..."
}
```
1. **File, Save As(파일, 다른 이름으로 저장)**를 선택합니다.
1. **Filename(파일 이름)**에 `.NET.build`를 입력합니다.
1. **Folder(폴더)**에 `/.c9/builders`를 입력합니다.
1. **저장**을 선택합니다.
1. 편집기에 `Program.cs` 파일의 내용이 표시된 상태로 메뉴 모음에서 **실행, 빌드 시스템, .NET**을 선택합니다. 그런 다음 **Run, Build(실행, 빌드)**를 선택합니다.
이 빌더는 `bin` 하위 디렉터리를 추가하고 `Debug` 하위 디렉터리를 `hello/obj` 하위 디렉터리에 추가합니다. 다음 키 파일 세 개에 유의하십시오.
+ `hello/bin/Debug/netcoreapp3.1/hello.dll` 파일은 실행 가능한 애플리케이션 파일입니다.
+ `hello/bin/Debug/netcoreapp3.1/hello.deps.json` 파일은 애플리케이션의 종속 항목을 나열합니다.
+ `hello/bin/Debug/netcoreapp3.1/hello.runtimeconfig.json` 파일은 애플리케이션의 버전과 공유 실행 시간을 지정합니다.
**참고**
폴더 이름 `netcoreapp3.1`은 이 예에 사용된 .NET SDK의 버전을 나타냅니다. 설치한 버전에 따라 폴더 이름에 다른 번호가 표시될 수 있습니다.
1. 다음과 같이 .NET용 실행기를 생성합니다.
1. 메뉴 모음에서 **Run, Run With, New Runner(실행, 실행 도구, 새 실행기)**를 선택합니다.
1. **My Runner.run** 탭에서 탭의 내용을 다음 코드로 바꿉니다.
```
{
"cmd" : ["dotnet", "run", "$args"],
"working_dir": "$file_path",
"info" : "Running..."
}
```
1. **File, Save As(파일, 다른 이름으로 저장)**를 선택합니다.
1. **Filename(파일 이름)**에 `.NET.run`를 입력합니다.
1. **Folder(폴더)**에 `/.c9/runners`를 입력합니다.
1. **저장**을 선택합니다.
1. 다음과 같이 추가할 두 정수(예: `5`와 `9`)를 지정하여 애플리케이션을 실행합니다.
1. 편집기에 `Program.cs` 파일의 내용이 표시된 상태로, **Run(실행), Run Configurations(실행 구성), New Run Configuration(새로운 실행 구성)**을 선택합니다.
1. **[새로 만들기] - 유휴** 탭에서 **실행기: 자동**을 선택한 다음 **.NET**을 선택합니다.
1. **Command(명령)** 상자에 `hello 5 9`를 입력합니다.
1. **실행**을 선택합니다.
기본적으로 이 실행기는 .NET에 `hello/bin/Debug/netcoreapp3.1` 디렉터리의 `hello.dll` 파일을 실행하도록 지시합니다.
출력을 다음과 비교합니다.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## 6단계:를 사용하는 .NET 콘솔 애플리케이션 프로젝트 생성 및 설정 AWS SDK for .NET
이 샘플을 개선하여 AWS SDK for .NET 를 사용하여 Amazon S3 버킷을 생성하고 사용 가능한 버킷을 나열한 다음 방금 생성한 버킷을 삭제할 수 있습니다.
이 새 프로젝트에서는 AWS SDK for .NET에 대한 참조를 추가합니다. 는 .NET 코드에서 Amazon S3와 같은 AWS 서비스와 상호 작용하는 편리한 방법을 AWS SDK for .NET 제공합니다. 그런 다음 환경에서 AWS 자격 증명 관리를 설정합니다. 는 AWS 서비스와 상호 작용하기 위해 이러한 자격 증명이 AWS SDK for .NET 필요합니다.
### 프로젝트를 만들려면
1. .NET 콘솔 애플리케이션 프로젝트를 생성합니다. 이렇게 하려면 사용할 콘솔 애플리케이션 프로젝트 템플릿 유형 및 프로그래밍 언어를 지정하여 **`new`** 명령과 함께 .NET CLI를 실행합니다.
`-n` 옵션은 프로젝트가 `s3`라는 새 디렉터리로 출력됨을 나타냅니다. 그런 다음 해당 디렉터리로 이동합니다.
```
dotnet new console -lang C# -n s3
cd s3
```
1. AWS SDK for .NET에 Amazon S3 패키지에 대한 프로젝트 참조를 추가합니다. 이렇게 하려면, NuGet의 Amazon S3 패키지 이름을 지정하여** `add package` **명령으로 .NET CLI를 실행합니다. (NuGet은 .NET용 패키지의 생성, 호스팅 및 사용 방식을 정의하고 이러한 각 역할에 사용할 도구를 제공합니다.)
```
dotnet add package AWSSDK.S3
```
Amazon S3 패키지에 대한 프로젝트 참조를 추가하면 NuGet에서 AWS SDK for .NET의 나머지에 대한 프로젝트 참조도 추가합니다.
**참고**
NuGet의 기타 AWS 관련 패키지 이름 및 버전은 [NuGet 웹 사이트에서 aws-sdk로 태그가 지정된 NuGet 패키지를](https://www.nuget.org/packages?q=Tags%3A%22aws-sdk%22) 참조하세요. NuGet
### AWS 자격 증명 관리를 설정하려면
를 사용하여 AWS 서비스를 호출 AWS SDK for .NET 할 때마다 호출과 함께 자격 AWS 증명 세트를 제공해야 합니다. 이러한 자격 증명은에 해당 호출을 수행할 수 AWS SDK for .NET 있는 적절한 권한이 있는지 여부를 결정합니다. 자격 증명으로 적절한 권한이 확인되지 않는 경우 호출이 실패합니다.
환경에 자격 증명을 저장하려면 [AWS 서비스 의 환경에서 호출 AWS Cloud9](credentials.md)의 지침을 따른 다음 이 주제로 돌아옵니다.
자세한 내용은 *AWS SDK for .NET 개발자 안내서*의 [AWS 자격 증명 구성을 참조하세요](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html).
## 7단계: AWS SDK 코드 추가
이 단계에서는 Amazon S3와 상호 작용하는 코드를 추가하여 버킷을 생성하고 생성된 버킷을 삭제한 다음 사용 가능한 버킷의 목록을 나열합니다.
AWS Cloud9 IDE의 **환경** 창에서 `s3/Program.cs` 파일을 엽니다. 편집기에서 이 파일의 현재 내용을 다음 코드로 바꾼 다음 `Program.cs` 파일을 저장합니다.
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using Amazon.S3.Util;
using System;
using System.Threading.Tasks;
namespace s3
{
class Program
{
async static Task Main(string[] args)
{
if (args.Length < 2) {
Console.WriteLine("Usage: ");
Console.WriteLine("Example: my-test-bucket us-east-2");
return;
}
if (args[1] != "us-east-2") {
Console.WriteLine("Cannot continue. The only supported AWS Region ID is " +
"'us-east-2'.");
return;
}
var bucketRegion = RegionEndpoint.USEast2;
// Note: You could add more valid AWS Regions above as needed.
using (var s3Client = new AmazonS3Client(bucketRegion)) {
var bucketName = args[0];
// Create the bucket.
try
{
if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
{
Console.WriteLine("Cannot continue. Cannot create bucket. \n" +
"A bucket named '{0}' already exists.", bucketName);
return;
} else {
Console.WriteLine("\nCreating the bucket named '{0}'...", bucketName);
await s3Client.PutBucketAsync(bucketName);
}
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Cannot continue. {0}", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Cannot continue. {0}", e.Message);
}
// Confirm that the bucket was created.
if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
{
Console.WriteLine("Created the bucket named '{0}'.", bucketName);
} else {
Console.WriteLine("Did not create the bucket named '{0}'.", bucketName);
}
// Delete the bucket.
Console.WriteLine("\nDeleting the bucket named '{0}'...", bucketName);
await s3Client.DeleteBucketAsync(bucketName);
// Confirm that the bucket was deleted.
if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
{
Console.WriteLine("Did not delete the bucket named '{0}'.", bucketName);
} else {
Console.WriteLine("Deleted the bucket named '{0}'.", bucketName);
};
// List current buckets.
Console.WriteLine("\nMy buckets now are:");
var response = await s3Client.ListBucketsAsync();
foreach (var bucket in response.Buckets)
{
Console.WriteLine(bucket.BucketName);
}
}
}
}
}
```
## 8단계: AWS SDK 코드 빌드 및 실행
이 단계에서는 프로젝트 및 관련 종속 항목을 바이너리 파일 세트(실행 가능한 애플리케이션 파일 포함)로 빌드합니다. 그런 다음 애플리케이션을 실행합니다.
1. 프로젝트를 빌드합니다. 이렇게 하려면 편집기에 `s3/Program.cs`파일의 내용이 표시된 상태로 메뉴 모음에서 **Run, Build(실행, 빌드)**를 선택합니다.
1. 다음과 같이 생성할 Amazon S3 버킷 이름과 및 버킷을 생성할 AWS 리전의 ID를 지정하여 애플리케이션(예: `my-test-bucket` 및 `us-east-2`)을 실행합니다.
1. 편집기에 `s3/Program.cs` 파일의 내용이 여전히 표시된 상태로, **Run(실행), Run Configurations(실행 구성), New Run Configuration(새로운 실행 구성)**을 선택합니다.
1. **[새로 만들기] - 유휴** 탭에서 **실행기: 자동**을 선택한 다음 **.NET**을 선택합니다.
1. **명령** 상자에 애플리케이션의 이름, 생성할 Amazon S3 버킷의 이름, 버킷을 생성할 AWS 리전의 ID(예: `s3 my-test-bucket us-east-2`)를 입력합니다.
1. **실행**을 선택합니다.
기본적으로 이 실행기는 .NET에 `s3/bin/Debug/netcoreapp3.1` 디렉터리의 `s3.dll` 파일을 실행하도록 지시합니다.
결과를 다음 출력과 비교합니다.
```
Creating a new bucket named 'my-test-bucket'...
Created the bucket named 'my-test-bucket'.
Deleting the bucket named 'my-test-bucket'...
Deleted the bucket named 'my-test-bucket'.
My buckets now are:
```
## 9단계: 정리
이 샘플 사용을 완료한 후 AWS 계정에 지속적인 요금이 부과되지 않도록 하려면 환경을 삭제해야 합니다. 지침은 [에서 환경 삭제 AWS Cloud9](delete-environment.md) 단원을 참조하세요.
# 에 대한 Node.js 자습서 AWS Cloud9
이 자습서를 사용하면 AWS Cloud9 개발 환경에서 일부 Node.js 스크립트를 실행할 수 있습니다.
이 자습서를 따르고이 샘플을 생성하면 AWS 계정에 요금이 부과될 수 있습니다. 여기에는 Amazon EC2 및 Amazon S3 같은 서비스에 대한 발생할 수 있는 요금이 포함됩니다. 자세한 내용은 [Amazon EC2 요금](https://aws.amazon.com/ec2/pricing/) 및 [Amazon S3 요금](https://aws.amazon.com/s3/pricing/)을 참조하세요.
**Topics**
+ [사전 조건](#sample-nodejs-prereqs)
+ [1단계: 필수 도구 설치](#sample-nodejs-install)
+ [2단계: 코드 추가](#sample-nodejs-code)
+ [3단계: 코드 실행](#sample-nodejs-run)
+ [4단계: Node.js에서 JavaScript용 AWS SDK 설치 및 구성](#sample-nodejs-sdk)
+ [5단계: AWS SDK 코드 추가](#sample-nodejs-sdk-code)
+ [6단계: AWS SDK 코드 실행](#sample-nodejs-sdk-run)
+ [7단계: 정리](#sample-nodejs-clean-up)
## 사전 조건
이 샘플을 사용하기 전에 설정이 다음 요구 사항을 충족하는지 확인하세요.
+ **기존 AWS Cloud9 EC2 개발 환경이 있어야 합니다.** 이 샘플에서는 Amazon Linux 또는 Ubuntu 서버를 실행 중인 Amazon EC2 인스턴스에 연결된 EC2 환경이 이미 있다고 가정합니다. 다른 환경 또는 운영 시스템이라면 이 샘플 지침을 관련 도구를 설치하는 데에 적용해야 합니다. 자세한 내용은 [에서 환경 생성 AWS Cloud9](create-environment.md) 단원을 참조하십시오.
+ **기존 환경의 AWS Cloud9 IDE가 이미 열려 있습니다.** 환경을 열면 웹 브라우저에서 해당 환경의 IDE가 AWS Cloud9 열립니다. 자세한 내용은 [에서 환경 열기 AWS Cloud9](open-environment.md) 단원을 참조하십시오.
## 1단계: 필수 도구 설치
이 단계에서는 이 샘플을 실행할 때 필요한 Node.js를 설치합니다.
1. AWS Cloud9 IDE의 터미널 세션에서 ** `node --version` ** 명령을 실행하여 Node.js가 이미 설치되어 있는지 확인합니다. (터미널 세션을 새로 시작하려면 메뉴 모음에서 **Window(창)**, **New Terminal(새 터미널)**을 선택합니다.) 성공할 경우, 출력에 Node.js 버전 번호가 포함됩니다. Node.js가 설치된 경우 [2단계: 코드 추가](#sample-nodejs-code) 섹션으로 이동합니다.
1. **`yum update` **명령(Amazon Linux) 또는** `apt update` **명령(Ubuntu Server)을 실행하여 최신 보안 업데이트와 버그 수정이 설치되어 있는지 확인합니다.
Amazon Linux의 경우:
```
sudo yum -y update
```
Ubuntu Server:
```
sudo apt update
```
1. Node.js를 설치하려면, 먼저 이 명령을 실행하여 Node Version Manager(nvm)를 다운로드합니다. (nvm은 Node.js 버전을 설치하고 관리하는 데 유용한 간단한 Bash 셸 스크립트입니다. 자세한 내용은 GitHub 웹 사이트에서 [Node Version Manager](https://github.com/creationix/nvm/blob/master/README.md)를 참조하세요.)
```
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.5/install.sh | bash
```
1. nvm 사용을 시작하려면 터미널 세션을 닫고 나서 다시 시작하거나, nvm을 로드하는 명령을 포함하는 `~/.bashrc` 파일을 소싱합니다.
```
. ~/.bashrc
```
1. 이 명령을 실행하여 Amazon Linux 2, Amazon Linux 1, Ubuntu 18.04.에 Node.js 16을 설치합니다. Amazon Linux 1 및 Ubuntu 18.04 인스턴스는 Node.js v16까지만 지원합니다.
```
nvm install 16
```
이 명령을 실행하여 Amazon Linux 2023 및 Ubuntu 22.04에 Node.js의 최신 버전을 설치합니다.
```
nvm install --lts && nvm alias default lts/*
```
**참고**
최신 AL2023 AWS Cloud9 image에는 Node.js 20이 설치되어 있고 최신 Amazon Linux 2 AWS Cloud9 image에는 Node.js 18이 설치되어 있습니다. Amazon Linux 2에 Node.js 18을 AWS Cloud9 수동으로 설치하려면 AWS Cloud9 IDE 터미널에서 다음 명령을 실행합니다.
```
C9_NODE_INSTALL_DIR=~/.nvm/versions/node/v18.17.1
C9_NODE_URL=https://d3kgj69l4ph6w4.cloudfront.net/static/node-amazon/node-v18.17.1-linux-x64.tar.gz
mkdir -p $C9_NODE_INSTALL_DIR
curl -fSsl $C9_NODE_URL | tar xz --strip-components=1 -C "$C9_NODE_INSTALL_DIR"
nvm alias default v18.17.1
nvm use default
echo -e 'nvm use default' >> ~/.bash_profile
```
## 2단계: 코드 추가
AWS Cloud9 IDE에서이 콘텐츠가 포함된 파일을 생성하고 이름이 인 파일을 저장합니다`hello.js`. (파일을 생성하려면 메뉴 모음에서 [**파일(File)**], [**새 파일(New File)**]을 선택합니다. 파일을 저장하려면 [**파일(File)**], [**저장(Save)**]을 선택합니다.)
```
console.log('Hello, World!');
console.log('The sum of 2 and 3 is 5.');
var sum = parseInt(process.argv[2], 10) + parseInt(process.argv[3], 10);
console.log('The sum of ' + process.argv[2] + ' and ' +
process.argv[3] + ' is ' + sum + '.');
```
## 3단계: 코드 실행
1. AWS Cloud9 IDE의 메뉴 모음에서 **실행**, **실행 구성**, **새 실행 구성을** 선택합니다.
1. [**[새로 만들기] - 유휴([New] - Idle)**] 탭에서 [**러너: 자동(Runner: Auto)**]을 선택한 다음 [**Node.js**]를 선택합니다.
1. **명령**에 `hello.js 5 9`를 입력합니다. 코드에서 `5`는 `process.argv[2]`를 나타내고 `9`는 `process.argv[3]`를 나타냅니다. (`process.argv[0]`는 런타임의 이름(`node`)을 나타내고 `process.argv[1]`는 파일의 이름(`hello.js`)을 나타냅니다.)
1. **Run(실행)** 버튼을 선택하여 출력값을 비교합니다.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[AWS Cloud9 IDE에서 코드를 실행한 후 Node.js 출력\]](http://docs.aws.amazon.com/ko_kr/cloud9/latest/user-guide/images/ide-nodejs-simple.png)
## 4단계: Node.js에서 JavaScript용 AWS SDK 설치 및 구성
에서 Node.js 스크립트를 실행할 때 AWS SDK for JavaScript 버전 3(V3)과 이전 AWS SDK for JavaScript 버전 2(V2) 중에서 선택할 AWS Cloud9수 있습니다. V2와 마찬가지로, V3를 사용하면 Amazon Web Services를 쉽게 사용할 수 있지만 TypeScript로 작성되었으며 모듈화된 패키지와 같이 자주 요청되는 몇 가지 기능이 추가되었다는 점이 다릅니다.
------
#### [ AWS SDK for JavaScript (V3) ]
이 샘플을 개선하여 Node.js의 JavaScript용 AWS SDK를 사용하여 Amazon S3 버킷을 생성하고, 사용 가능한 버킷을 나열한 다음, 방금 생성한 버킷을 삭제할 수 있습니다.
이 단계에서는 JavaScript 코드에서 Amazon S3 AWS 서비스와 상호 작용할 수 있는 편리한 방법을 제공하는 AWS SDK for JavaScript in Node.js의 Amazon S3 서비스 클라이언트 모듈을 설치 및 구성합니다.
다른 AWS 서비스를 사용하려면 별도로 설치해야 합니다. AWS 모듈 설치에 대한 자세한 내용은 [*AWS 개발자 안내서(V3)*의 섹션을 참조하세요.](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/working-with-services) Node.js 및 AWS SDK for JavaScript(V3)를 시작하는 방법에 대한 자세한 내용은 SDK for JavaScript 개발자 안내서(V3)의 [ Node.js 시작하기](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/getting-started-nodejs.html#getting-started-nodejs-setup-structure)를 참조하세요. *AWS JavaScript *
AWS SDK for JavaScript를 Node.js에 설치한 후에는 환경에서 자격 증명 관리를 설정해야 합니다. Node.js의 JavaScript용 AWS SDK는 서비스와 상호 작용하기 위해 이러한 자격 증명이 AWS 필요합니다.
**Node.js에 AWS SDK for JavaScript를 설치하려면**
npm을 사용하여 **`install`** 명령을 실행합니다.
```
npm install @aws-sdk/client-s3
```
자세한 내용은 *AWS SDK for JavaScript 개발자 가이드*에서 [SDK for JavaScript 설치](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-up.html#installing-jssdk)를 참조하세요.
**환경에서 보안 인증 관리를 설정하려면**
Node.js의 JavaScript용 AWS SDK를 사용하여 AWS 서비스를 호출할 때마다 호출과 함께 자격 증명 세트를 제공해야 합니다. 이러한 자격 증명은 AWS SDK for JavaScript in Node.js가 해당 호출을 할 수 있는 적절한 권한이 있는지 여부를 결정합니다. 자격 증명으로 적절한 권한이 확인되지 않는 경우 호출이 실패합니다.
이 단계에서는 환경 내에서 자격 증명을 저장합니다. 이렇게 하려면 [AWS 서비스 의 환경에서 호출 AWS Cloud9](credentials.md) 섹션의 지침을 수행한 다음 이 주제로 돌아옵니다.
자세한 내용은 *AWS SDK for JavaScript 개발자 가이드*의 [Node.js에서 자격 증명 설정](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/setting-credentials-node.html)을 참조하세요.
------
#### [ AWS SDK for JavaScript (V2) ]
이 샘플을 개선하여 Node.js의 JavaScript용 AWS SDK를 사용하여 Amazon S3 버킷을 생성하고, 사용 가능한 버킷을 나열한 다음, 방금 생성한 버킷을 삭제할 수 있습니다.
이 단계에서는 JavaScript 코드에서 Amazon S3와 같은 AWS 서비스와 상호 작용하는 편리한 방법을 제공하는 Node.js의 JavaScript용 AWS SDK를 설치하고 구성합니다. AWS SDK for JavaScript를 Node.js에 설치한 후에는 환경에서 자격 증명 관리를 설정해야 합니다. Node.js의 JavaScript용 AWS SDK는 서비스와 상호 작용하기 위해 이러한 자격 증명이 AWS 필요합니다.
**Node.js에 AWS SDK for JavaScript를 설치하려면**
npm을 사용하여 **`install`** 명령을 실행합니다.
```
npm install aws-sdk
```
자세한 내용은 *AWS SDK for JavaScript 개발자 가이드*에서 [SDK for JavaScript 설치](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/installing-jssdk.html)를 참조하세요.
**환경에서 보안 인증 관리를 설정하려면**
Node.js의 JavaScript용 AWS SDK를 사용하여 AWS 서비스를 호출할 때마다 호출과 함께 자격 증명 세트를 제공해야 합니다. 이러한 자격 증명은 AWS SDK for JavaScript in Node.js가 해당 호출을 할 수 있는 적절한 권한이 있는지 여부를 결정합니다. 자격 증명으로 적절한 권한이 확인되지 않는 경우 호출이 실패합니다.
이 단계에서는 환경 내에서 자격 증명을 저장합니다. 이렇게 하려면 [AWS 서비스 의 환경에서 호출 AWS Cloud9](credentials.md) 섹션의 지침을 수행한 다음 이 주제로 돌아옵니다.
자세한 내용은 *AWS SDK for JavaScript 개발자 가이드*의 [Node.js에서 자격 증명 설정](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/setting-credentials-node.html)을 참조하세요.
------
## 5단계: AWS SDK 코드 추가
------
#### [ AWS SDK for JavaScript (V3) ]
이 단계에서는 몇 가지 코드를 더 추가합니다. 이번 경우에는 Amazon S3와 상호 작용하기 위한 것이며 버킷을 생성하고 사용 가능한 버킷을 나열한 다음 막 생성한 버킷을 삭제합니다. 이 코드를 나중에 실행합니다.
AWS Cloud9 IDE에서이 콘텐츠가 포함된 파일을 생성하고 이름이 인 파일을 저장합니다`s3.js`.
```
import {
CreateBucketCommand,
DeleteBucketCommand,
ListBucketsCommand,
S3Client,
} from "@aws-sdk/client-s3";
const wait = async (milliseconds) => {
return new Promise((resolve) => setTimeout(resolve, milliseconds));
};
export const main = async () => {
const client = new S3Client({});
const now = Date.now();
const BUCKET_NAME = `easy-bucket-${now.toString()}`;
const createBucketCommand = new CreateBucketCommand({ Bucket: BUCKET_NAME });
const listBucketsCommand = new ListBucketsCommand({});
const deleteBucketCommand = new DeleteBucketCommand({ Bucket: BUCKET_NAME });
try {
console.log(`Creating bucket ${BUCKET_NAME}.`);
await client.send(createBucketCommand);
console.log(`${BUCKET_NAME} created`);
await wait(2000);
console.log(`Here are your buckets:`);
const { Buckets } = await client.send(listBucketsCommand);
Buckets.forEach((bucket) => {
console.log(` • ${bucket.Name}`);
});
await wait(2000);
console.log(`Deleting bucket ${BUCKET_NAME}.`);
await client.send(deleteBucketCommand);
console.log(`${BUCKET_NAME} deleted`);
} catch (err) {
console.error(err);
}
};
main();
```
------
#### [ AWS SDK for JavaScript (V2) ]
이 단계에서는 몇 가지 코드를 더 추가합니다. 이번 경우에는 Amazon S3와 상호 작용하기 위한 것이며 버킷을 생성하고 사용 가능한 버킷을 나열한 다음 막 생성한 버킷을 삭제합니다. 이 코드를 나중에 실행합니다.
AWS Cloud9 IDE에서이 콘텐츠가 포함된 파일을 생성하고 이름이 인 파일을 저장합니다`s3.js`.
```
if (process.argv.length < 4) {
console.log(
"Usage: node s3.js \n" +
"Example: node s3.js my-test-bucket us-east-2"
);
process.exit(1);
}
var AWS = require("aws-sdk"); // To set the AWS credentials and region.
var async = require("async"); // To call AWS operations asynchronously.
AWS.config.update({
region: region,
});
var s3 = new AWS.S3({ apiVersion: "2006-03-01" });
var bucket_name = process.argv[2];
var region = process.argv[3];
var create_bucket_params = {
Bucket: bucket_name,
CreateBucketConfiguration: {
LocationConstraint: region,
},
};
var delete_bucket_params = { Bucket: bucket_name };
// List all of your available buckets in this AWS Region.
function listMyBuckets(callback) {
s3.listBuckets(function (err, data) {
if (err) {
} else {
console.log("My buckets now are:\n");
for (var i = 0; i < data.Buckets.length; i++) {
console.log(data.Buckets[i].Name);
}
}
callback(err);
});
}
// Create a bucket in this AWS Region.
function createMyBucket(callback) {
console.log("\nCreating a bucket named " + bucket_name + "...\n");
s3.createBucket(create_bucket_params, function (err, data) {
if (err) {
console.log(err.code + ": " + err.message);
}
callback(err);
});
}
// Delete the bucket you just created.
function deleteMyBucket(callback) {
console.log("\nDeleting the bucket named " + bucket_name + "...\n");
s3.deleteBucket(delete_bucket_params, function (err, data) {
if (err) {
console.log(err.code + ": " + err.message);
}
callback(err);
});
}
// Call the AWS operations in the following order.
async.series([
listMyBuckets,
createMyBucket,
listMyBuckets,
deleteMyBucket,
listMyBuckets,
]);
```
------
## 6단계: AWS SDK 코드 실행
1. 코드에서 npm을 사용하여** `install` **명령을 실행함으로써 Amazon S3 작업을 비동기로 호출할 수 있게 합니다.
```
npm install async
```
1. AWS Cloud9 IDE의 메뉴 모음에서 **실행**, **실행 구성**, **새 실행 구성을** 선택합니다.
1. [**[새로 만들기] - 유휴([New] - Idle)**] 탭에서 [**러너: 자동(Runner: Auto)**]을 선택한 다음 [**Node.js**]를 선택합니다.
1. AWS SDK for JavaScript(V3)를 사용하는 경우 **명령** 유형 `s3.js`. AWS SDK for Javascript(v2)를 사용하는 경우 **명령** 유형에서 `s3.js my-test-bucket us-east-2``my-test-bucket`는 생성 후 삭제할 버킷의 이름이고 `us-east-2`는 버킷을 생성할 AWS 리전의 ID입니다. 더 많은 ID는 **Amazon Web Services 일반 참조의 [Amazon Simple Storage Service(Amazon S3)](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region)를 참조하세요.
**참고**
Amazon S3 버킷 이름은 계정 AWS 뿐만 AWS아니라 여러 계정에서 고유해야 합니다.
1. **Run(실행)** 버튼을 선택하여 출력값을 비교합니다.
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## 7단계: 정리
이 샘플 사용을 완료한 후 AWS 계정에 요금이 계속 부과되지 않도록 하려면 환경을 삭제해야 합니다. 지침은 [에서 환경 삭제 AWS Cloud9](delete-environment.md) 단원을 참조하세요.
# 에 대한 PHP 자습서 AWS Cloud9
이 자습서를 사용하면 AWS Cloud9 개발 환경에서 일부 PHP 스크립트를 실행할 수 있습니다.
이 자습서를 따르고 이 샘플을 생성하면 AWS 계정에 요금이 발생할 수 있습니다. 여기에는 Amazon EC2 및 Amazon S3 같은 서비스에 대한 발생할 수 있는 요금이 포함됩니다. 자세한 내용은 [Amazon EC2 요금](https://aws.amazon.com/ec2/pricing/) 및 [Amazon S3 요금](https://aws.amazon.com/s3/pricing/)을 참조하세요.
**Topics**
+ [사전 조건](#sample-php-prereqs)
+ [1단계: 필수 도구 설치](#sample-php-install)
+ [2단계: 코드 추가](#sample-php-code)
+ [3단계: 코드 실행](#sample-php-run)
+ [4단계: 설치 및 구성 AWS SDK for PHP](#sample-php-sdk)
+ [5단계: AWS SDK 코드 추가](#sample-php-sdk-code)
+ [6단계: AWS SDK 코드 실행](#sample-php-sdk-run)
+ [7단계: 정리](#sample-php-clean-up)
## 사전 조건
이 샘플을 사용하기 전에 설정이 다음 요구 사항을 충족하는지 확인하세요.
+ **기존 AWS Cloud9 EC2 개발 환경이 있어야 합니다.** 이 샘플에서는 Amazon Linux 또는 Ubuntu 서버를 실행 중인 Amazon EC2 인스턴스에 연결된 EC2 환경이 이미 있다고 가정합니다. 다른 환경 또는 운영 시스템이라면 이 샘플 지침을 관련 도구를 설치하는 데에 적용해야 합니다. 자세한 내용은 [에서 환경 생성 AWS Cloud9](create-environment.md) 단원을 참조하십시오.
+ **기존 환경의 AWS Cloud9 IDE가 이미 열려 있습니다.** 환경을 열면가 웹 브라우저에서 해당 환경의 IDE를 AWS Cloud9 엽니다. 자세한 내용은 [에서 환경 열기 AWS Cloud9](open-environment.md) 단원을 참조하십시오.
## 1단계: 필수 도구 설치
이 단계에서는 이 샘플을 실행할 때 필요한 PHP를 설치합니다.
**참고**
다음 절차에서는 PHP만 설치합니다. Apache 웹 서버 및 MySQL 데이터베이스와 같은 관련 도구를 설치하려면 *Amazon EC2 사용 설명서*에서 [자습서: Amazon Linux에 LAMP 웹 서버 설치](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/install-LAMP.html)를 참조하세요.
1. AWS Cloud9 IDE의 터미널 세션에서 ** `php --version` ** 명령을 실행하여 PHP가 이미 설치되어 있는지 확인합니다. (터미널 세션을 새로 시작하려면 메뉴 모음에서 **Window(창)**, **New Terminal(새 터미널)**을 선택합니다.) 성공할 경우, PHP 버전 숫자를 포함해 출력값이 생성됩니다. PHP가 설치된 경우 [2단계: 코드 추가](#sample-php-code)로 이동합니다.
1. **`yum update` **명령(Amazon Linux) 또는** `apt update` **명령(Ubuntu Server)을 실행하여 최신 보안 업데이트와 버그 수정이 설치되어 있는지 확인합니다.
Amazon Linux 2 및 Amazon Linux의 경우:
```
sudo yum -y update
```
Ubuntu Server:
```
sudo apt update
```
1. **`install` **명령을 실행하여 PHP를 설치합니다.
대상 Amazon Linux 2:
```
sudo amazon-linux-extras install -y php7.2
```
Amazon Linux의 경우:
```
sudo yum -y install php72
```
**참고**
다음 명령을 사용하여 Amazon Linux 버전을 볼 수 있습니다.
```
cat /etc/system-release
```
Ubuntu Server:
```
sudo apt install -y php php-xml
```
자세한 내용은 PHP 웹 사이트에서 [설치 및 구성](http://php.net/manual/en/install.php)을 참조하세요.
## 2단계: 코드 추가
AWS Cloud9 IDE에서이 콘텐츠가 포함된 파일을 생성하고 이름이 인 파일을 저장합니다`hello.php`. (파일을 생성하려면 메뉴 모음에서 [**파일(File)**], [**새 파일**]을 선택합니다. 파일을 저장하려면 [**파일(File)**], [**저장(Save)**]을 선택하고 [**파일 이름(Filename)**]에 `hello.php`을 입력한 다음 [**저장(Save)**]을 선택합니다.)
```
```
**참고**
위의 코드는 외부 파일에 종속되지 않습니다. 그러나 파일에 다른 PHP 파일을 포함하거나 요구하는 경우 해당 파일을 사용하여 입력할 때 코드 완성을 수행 AWS Cloud9 하려면 **기본 설정**에서 **프로젝트, PHP 지원, PHP 코드 완성 설정 활성화**를 켠 다음 해당 파일의 경로를 **프로젝트, PHP 지원, PHP 완성 포함 경로** 설정에 추가합니다. (기본 설정을 보고 변경하려면 메뉴 모음에서 **AWS Cloud9, Preferences**(기본 설정)를 선택합니다.)
## 3단계: 코드 실행
1. AWS Cloud9 IDE의 메뉴 모음에서 **실행**, **실행 구성**, **새 실행 구성을** 선택합니다.
1. [**[새로 만들기] - 유휴([New] - Idle)**] 탭에서 [**러너: 자동(Runner: Auto)**]을 선택한 다음 [**PHP(cli)**]를 선택합니다.
1. **명령**에 `hello.php 5 9`를 입력합니다. 코드에서 `5`는 `$argv[1]`를 나타내고 `9`는 `$argv[2]`를 나타냅니다. (`$argv[0]`는 파일의 이름(`hello.php`)을 나타냅니다.)
1. **Run(실행)** 버튼을 선택하여 출력값을 비교합니다.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[AWS Cloud9 IDE에서 PHP 코드 실행 출력\]](http://docs.aws.amazon.com/ko_kr/cloud9/latest/user-guide/images/ide-php-simple.png)
## 4단계: 설치 및 구성 AWS SDK for PHP
이 샘플을 개선하여 AWS SDK for PHP 를 사용하여 Amazon S3 버킷을 생성하고 사용 가능한 버킷을 나열한 다음 방금 생성한 버킷을 삭제할 수 있습니다.
이 단계에서는 PHP 코드에서 Amazon S3와 같은 AWS 서비스와 상호 작용하는 편리한 방법을 AWS SDK for PHP제공하는를 설치하고 구성합니다. 를 설치하려면 먼저 [Composer](https://getcomposer.org/)를 설치 AWS SDK for PHP해야 합니다. 를 설치 AWS SDK for PHP한 후에는 환경에서 자격 증명 관리를 설정해야 합니다. 는 AWS 서비스와 상호 작용하기 위해 이러한 자격 증명이 AWS SDK for PHP 필요합니다.
### Composer를 설치하려면
자동(`-s`) 및 오류 표시(`-S`) 옵션을 사용하여** `curl` **명령을 실행하고, Composer 설치 관리자를 `composer.phar`(명명 규칙에 따른 이름)이라는 PHP 아카이브(PHAR) 파일로 파이핑합니다.
```
curl -sS https://getcomposer.org/installer | php
```
### 를 설치하려면 AWS SDK for PHP
Ubuntu Server의 경우, Composer가 AWS SDK for PHP를 설치하는 데 필요한 추가 패키지를 설치합니다.
```
sudo apt install -y php-xml php-curl
```
Amazon Linux 또는 Ubuntu Server의 경우 **php** 명령을 사용하여 Composer 설치 관리자를 실행하여 AWS SDK for PHP를 설치합니다.
```
php composer.phar require aws/aws-sdk-php
```
이 명령은 사용자 환경에 여러 폴더와 파일을 만듭니다. 사용할 주 파일은 `autoload.php`이고 환경의 `vendor` 폴더에 있습니다.
**참고**
설치 후 Composer는 추가 종속 구성 요소를 설치하도록 제안할 수 있습니다. 설치할 종속 구성 요소 목록을 지정하고 다음과 같은 명령을 사용하여 아룰 수행할 수 있습니다. 예를 들어 다음 명령은 종속 구성 요소의 다음 목록을 설치하도록 Composer에 지시합니다.
```
php composer.phar require psr/log ext-curl doctrine/cache aws/aws-php-sns-message-validator
```
자세한 내용은 *AWS SDK for PHP 개발자 가이드*에서 [설치](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/installation.html)를 참조하세요.
### 환경에서 보안 인증 관리를 설정하려면
를 사용하여 AWS 서비스를 호출 AWS SDK for PHP 할 때마다 호출과 함께 자격 증명 세트를 제공해야 합니다. 이러한 자격 증명은에 해당 호출을 수행할 수 AWS SDK for PHP 있는 적절한 권한이 있는지 여부를 결정합니다. 자격 증명으로 적절한 권한이 확인되지 않는 경우 호출이 실패합니다.
이 단계에서는 환경 내에서 자격 증명을 저장합니다. 이렇게 하려면 [AWS 서비스 의 환경에서 호출 AWS Cloud9](credentials.md) 섹션의 지침을 수행한 다음 이 주제로 돌아옵니다.
자세한 내용은 *AWS SDK for PHP 개발자 가이드*에서 [기본 사용법](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/basic-usage.html)의 ‘클라이언트 생성’ 섹션을 참조하세요.
## 5단계: AWS SDK 코드 추가
이 단계에서는 몇 가지 코드를 더 추가합니다. 이번 경우에는 Amazon S3와 상호 작용하기 위한 것이며 버킷을 생성하고 사용 가능한 버킷을 나열한 다음 막 생성한 버킷을 삭제합니다. 이 코드를 나중에 실행합니다.
AWS Cloud9 IDE에서이 콘텐츠가 포함된 파일을 생성하고 이름이 인 파일을 저장합니다`s3.php`.
```
\n" .
"Example: php s3.php America/Los_Angeles my-test-bucket us-east-2");
}
$timeZone = $argv[1];
$bucketName = $argv[2];
$region = $argv[3];
date_default_timezone_set($timeZone);
$s3 = new Aws\S3\S3Client([
'region' => $region,
'version' => '2006-03-01'
]);
# Lists all of your available buckets in this AWS Region.
function listMyBuckets($s3)
{
print("\nMy buckets now are:\n");
$promise = $s3->listBucketsAsync();
$result = $promise->wait();
foreach ($result['Buckets'] as $bucket) {
print("\n");
print($bucket['Name']);
}
}
listMyBuckets($s3);
# Create a new bucket.
print("\n\nCreating a new bucket named '$bucketName'...\n");
try {
$promise = $s3->createBucketAsync([
'Bucket' => $bucketName,
'CreateBucketConfiguration' => [
'LocationConstraint' => $region
]
]);
$promise->wait();
} catch (Exception $e) {
if ($e->getCode() == 'BucketAlreadyExists') {
exit("\nCannot create the bucket. " .
"A bucket with the name '$bucketName' already exists. Exiting.");
}
}
listMyBuckets($s3);
# Delete the bucket you just created.
print("\n\nDeleting the bucket named '$bucketName'...\n");
$promise = $s3->deleteBucketAsync([
'Bucket' => $bucketName
]);
$promise->wait();
listMyBuckets($s3);
?>
```
## 6단계: AWS SDK 코드 실행
1. AWS Cloud9 IDE의 메뉴 모음에서 **실행**, **실행 구성**, **새 실행 구성을** 선택합니다.
1. [**[새로 만들기] - 유휴([New] - Idle)**] 탭에서 [**러너: 자동(Runner: Auto)**]을 선택한 다음 [**PHP(cli)**]를 선택합니다.
1. **명령**에 `s3.php America/Los_Angeles my-test-bucket us-east-2`을 입력합니다.
+ `America/Los_Angeles`는 기본 시간대 ID입니다. 더 많은 ID를 보려면 PHP 웹 사이트에서 [지원되는 시간대 목록](http://php.net/manual/en/timezones.php)을 참조하세요.
+ `my-test-bucket`은 생성한 다음 삭제하려는 버킷 이름입니다.
**참고**
Amazon S3 버킷 이름은 계정 AWS 뿐만 AWS아니라 여러 계정에서 고유해야 합니다.
+ `us-east-2`는 버킷을 생성하려는 AWS 리전의 ID입니다. 더 많은 ID는 **Amazon Web Services 일반 참조의 [Amazon Simple Storage Service(Amazon S3)](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region)를 참조하세요.
1. **Run(실행)** 버튼을 선택하여 출력값을 비교합니다.
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## 7단계: 정리
이 샘플 사용을 완료한 후 AWS 계정에 지속적인 요금이 부과되지 않도록 하려면 환경을 삭제해야 합니다. 지침은 [에서 환경 삭제 AWS Cloud9](delete-environment.md) 섹션을 참조하세요.
### 용 PHP 러너 관련 문제 해결 AWS Cloud9
PHP CLI 러너에서 문제가 발생하는 경우, 러너가 PHP로 설정되어 있고 디버거 모드가 활성화되어 있는지 확인해야 합니다.
# AWS 의 Ruby용 SDK AWS Cloud9
AWS SDK for Ruby와 AWS Cloud9 함께를 사용하는 방법에 대한 자세한 내용은 [AWS SDK for Ruby 개발자 안내서의 SDK for Ruby와 함께 사용을 AWS Cloud9](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/cloud9-ruby.html) 참조하세요. *AWS *
**참고**
이 자습서를 따르면 AWS 계정에 요금이 부과될 수 있습니다. 여기에는 Amazon EC2 및 Amazon S3 같은 서비스에 대한 발생할 수 있는 요금이 포함됩니다. 자세한 내용은 [Amazon EC2 요금](https://aws.amazon.com/ec2/pricing/) 및 [Amazon S3 요금](https://aws.amazon.com/s3/pricing/)을 참조하세요.
# Go 자습서 AWS Cloud9
이 자습서를 사용하면 AWS Cloud9 개발 환경에서 일부 Go 코드를 실행할 수 있습니다.
이 자습서를 따르고이 샘플을 생성하면 AWS 계정에 요금이 부과될 수 있습니다. 여기에는 Amazon EC2 및 Amazon S3 같은 서비스에 대한 발생할 수 있는 요금이 포함됩니다. 자세한 내용은 [Amazon EC2 요금](https://aws.amazon.com/ec2/pricing/) 및 [Amazon S3 요금](https://aws.amazon.com/s3/pricing/)을 참조하세요.
**Topics**
+ [사전 조건](#sample-go-prereqs)
+ [1단계: 필수 도구 설치](#sample-go-install)
+ [2단계: 코드 추가](#sample-go-code)
+ [3단계: 코드 실행](#sample-go-run)
+ [4단계: 설치 및 구성 AWS SDK for Go](#sample-go-sdk)
+ [5단계: AWS SDK 코드 추가](#sample-go-sdk-code)
+ [6단계: AWS SDK 코드 실행](#sample-go-sdk-run)
+ [7단계: 정리](#sample-go-clean-up)
## 사전 조건
이 샘플을 사용하기 전에 설정이 다음 요구 사항을 충족하는지 확인하세요.
+ **기존 AWS Cloud9 EC2 개발 환경이 있어야 합니다.** 이 샘플에서는 Amazon Linux 또는 Ubuntu 서버를 실행 중인 Amazon EC2 인스턴스에 연결된 EC2 환경이 이미 있다고 가정합니다. 다른 환경 또는 운영 시스템이라면 이 샘플 지침을 관련 도구를 설치하는 데에 적용해야 합니다. 자세한 내용은 [에서 환경 생성 AWS Cloud9](create-environment.md) 단원을 참조하십시오.
+ **기존 환경의 AWS Cloud9 IDE가 이미 열려 있습니다.** 환경을 열면가 웹 브라우저에서 해당 환경의 IDE를 AWS Cloud9 엽니다. 자세한 내용은 [에서 환경 열기 AWS Cloud9](open-environment.md) 단원을 참조하십시오.
## 1단계: 필수 도구 설치
이 단계에서는 이 샘플을 실행할 때 필요한 Go를 설치하고 구성합니다.
1. AWS Cloud9 IDE의 터미널 세션에서 ** `go version` ** 명령을 실행하여 Go가 이미 설치되어 있는지 확인합니다. (터미널 세션을 새로 시작하려면 메뉴 모음에서 **Window(창)**, **New Terminal(새 터미널)**을 선택합니다.) 성공할 경우, 출력에 Go 버전 번호가 포함됩니다. 그렇지 않으면 오류 메시지가 출력됩니다. Go가 설치된 경우 [2단계: 코드 추가](#sample-go-code) 섹션으로 건너뜁니다.
1. **`yum update` **명령(Amazon Linux) 또는** `apt update` **명령(Ubuntu Server)을 실행하여 최신 보안 업데이트와 버그 수정이 설치되어 있는지 확인합니다.
Amazon Linux의 경우:
```
sudo yum -y update
```
Ubuntu Server:
```
sudo apt update
```
1. Go를 설치하려면 한 번에 하나씩 다음 명령을 실행합니다.
```
wget https://storage.googleapis.com/golang/go1.9.3.linux-amd64.tar.gz # Download the Go installer.
sudo tar -C /usr/local -xzf ./go1.9.3.linux-amd64.tar.gz # Install Go.
rm ./go1.9.3.linux-amd64.tar.gz # Delete the installer.
```
앞의 명령은 이 주제가 작성된 당시의 안정된 최신 버전의 Go를 기준으로 합니다. 자세한 내용은 Go 프로그래밍 언어 웹 사이트에서 [다운로드](https://golang.org/dl/)를 참조하세요.
1. 다음과 같이 Go 바이너리에 대한 경로를 `PATH` 환경 변수에 추가합니다.
1. 편집을 위해 셸 프로파일 파일(예: `~/.bashrc`)을 엽니다.
1. 이 코드 줄 끝에 다음을 입력하여 코드가 다음과 같이 표시되도록 합니다.
```
PATH=$PATH:/usr/local/go/bin
```
1. 파일을 저장합니다.
1. 터미널이 방금 참조한 Go 바이너리를 찾을 수 있도록 `~/.bashrc` 파일을 소스로 지정합니다.
```
. ~/.bashrc
```
1. **`go version` **명령을 실행하여 Go가 성공적으로 설치 및 구성되었는지 확인합니다. 성공할 경우, 출력에 Go 버전 번호가 포함됩니다.
## 2단계: 코드 추가
AWS Cloud9 IDE에서이 콘텐츠가 포함된 파일을 생성하고 이름이 인 파일을 저장합니다`hello.go`. (파일을 생성하려면 메뉴 모음에서 [**파일(File)**], [**새 파일(New File)**]을 선택합니다. 파일을 저장하려면 [**파일(File)**], [**저장(Save)**]을 선택합니다.)
```
package main
import (
"fmt"
"os"
"strconv"
)
func main() {
fmt.Printf("Hello, World!\n")
fmt.Printf("The sum of 2 and 3 is 5.\n")
first, _ := strconv.Atoi(os.Args[1])
second, _ := strconv.Atoi(os.Args[2])
sum := first + second
fmt.Printf("The sum of %s and %s is %s.",
os.Args[1], os.Args[2], strconv.Itoa(sum))
}
```
## 3단계: 코드 실행
1. AWS Cloud9 IDE의 메뉴 모음에서 **실행**, **실행 구성**, **새 실행 구성을** 선택합니다.
1. [**[새로 만들기] - 유휴([New] - Idle)**] 탭에서 [**러너: 자동(Runner: Auto)**]을 선택한 다음 [**Go**]를 선택합니다.
**참고**
**Go**를 사용할 수 없는 경우 Go용 사용자 지정 러너를 생성할 수 있습니다.
**[New] - Idle([새로 만들기] = 유휴)** 탭에서 **Runner: Auto(실행기: 자동)**를 선택하고 나서 **New Runner(새 실행기)**를 선택합니다.
**My Runner.run(내 실행기.run)** 탭에서 탭의 내용을 이 코드로 바꿉니다.
```
{
"cmd" : ["go", "run", "$file", "$args"],
"info" : "Running $project_path$file_name...",
"selector" : "source.go"
}
```
메뉴 모음에서 **File(파일)**, **Save As(다른 이름으로 저장)**를 선택한 후 파일을 `/.c9/runners` 폴더의 `Go.run`으로 저장합니다.
[**[새로 만들기] - 유휴([New] - Idle)**] 탭에서 [**러너: 자동(Runner: Auto)**]을 선택한 다음 [**Go**]를 선택합니다.
**hello.go** 탭을 선택하여 활성화합니다.
1. **명령**에 `hello.go 5 9`를 입력합니다. 이 코드에서 `5`는 `os.Args[1]`을 나타내고 `9`는 `os.Args[2]`를 나타냅니다.
![\[AWS Cloud9 IDE에서 Go 코드를 실행하는 출력\]](http://docs.aws.amazon.com/ko_kr/cloud9/latest/user-guide/images/ide-go-simple.png)
1. **Run(실행)** 버튼을 선택하여 출력값을 비교합니다.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## 4단계: 설치 및 구성 AWS SDK for Go
이 샘플을 개선하여 AWS SDK for Go 를 사용하여 Amazon S3 버킷을 생성하고 사용 가능한 버킷을 나열한 다음 방금 생성한 버킷을 삭제할 수 있습니다.
이 단계에서는 Go 코드에서 Amazon S3와 같은 AWS 서비스와 상호 작용하는 편리한 방법을 AWS SDK for Go제공하는를 설치하고 구성합니다. AWS SDK for Go를 설치하기 전에 `GOPATH` 환경 변수를 설정해야 합니다. AWS SDK for Go 를 설치하고 `GOPATH` 환경 변수를 설정한 후에는 환경에서 자격 증명 관리를 설정해야 합니다. 는 서비스와 상호 작용하기 위해 이러한 자격 증명이 AWS SDK for Go AWS 필요합니다.
### GOPATH 환경 변수를 설정하려면
1. 편집을 위해 `~/.bashrc` 파일을 엽니다.
1. 파일의 마지막 줄 뒤에 이 코드를 입력합니다.
```
GOPATH=~/environment/go
export GOPATH
```
1. 파일을 저장합니다.
1. 터미널이 방금 참조한 `GOPATH` 환경 변수를 찾을 수 있도록 `~/.bashrc` 파일을 소스로 지정합니다.
```
. ~/.bashrc
```
1. **`echo $GOPATH` **명령을 실행하여 `GOPATH` 환경 변수가 성공적으로 설정되었는지 확인합니다. 성공적으로 설정된 경우 `/home/ec2-user/environment/go` 또는 `/home/ubuntu/environment/go`가 출력되어야 합니다.
### 를 설치하려면 AWS SDK for Go
** `go get` ** 명령을 실행하여 AWS SDK for Go 소스의 위치를 지정합니다.
```
go get -u github.com/aws/aws-sdk-go/...
```
Go는 환경 변수, 즉 `GOPATH` 환경의 `go` 폴더에 지정된 위치에 AWS SDK for Go 소스를 설치합니다.
### 환경에서 보안 인증 관리를 설정하려면
를 사용하여 AWS 서비스를 호출 AWS SDK for Go 할 때마다 호출과 함께 자격 증명 세트를 제공해야 합니다. 이러한 자격 증명은에 해당 호출을 수행할 수 AWS SDK for Go 있는 적절한 권한이 있는지 여부를 결정합니다. 자격 증명으로 적절한 권한이 확인되지 않는 경우 호출이 실패합니다.
이 단계에서는 환경 내에서 자격 증명을 저장합니다. 이렇게 하려면 [AWS 서비스 의 환경에서 호출 AWS Cloud9](credentials.md) 섹션의 지침을 수행한 다음 이 주제로 돌아옵니다.
자세한 내용은 *AWS SDK for Go 개발자 가이드*에서 [자격 증명 지정](https://docs.aws.amazon.com/sdk-for-go/latest/developer-guide/configuring-sdk.html#specifying-credentials)을 참조하세요.
## 5단계: AWS SDK 코드 추가
이 단계에서는 몇 가지 코드를 더 추가합니다. 이번 경우에는 Amazon S3와 상호 작용하기 위한 것이며 버킷을 생성하고 사용 가능한 버킷을 나열한 다음 막 생성한 버킷을 삭제합니다. 이 코드를 나중에 실행합니다.
AWS Cloud9 IDE에서이 콘텐츠가 포함된 파일을 생성하고 이름이 인 파일을 저장합니다`s3.go`.
```
package main
import (
"fmt"
"os"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/s3"
)
func main() {
if len(os.Args) < 3 {
fmt.Printf("Usage: go run s3.go \n" +
"Example: go run s3.go my-test-bucket us-east-2\n")
os.Exit(1)
}
sess := session.Must(session.NewSessionWithOptions(session.Options{
SharedConfigState: session.SharedConfigEnable,
}))
svc := s3.New(sess, &aws.Config{
Region: aws.String(os.Args[2]),
})
listMyBuckets(svc)
createMyBucket(svc, os.Args[1], os.Args[2])
listMyBuckets(svc)
deleteMyBucket(svc, os.Args[1])
listMyBuckets(svc)
}
// List all of your available buckets in this AWS Region.
func listMyBuckets(svc *s3.S3) {
result, err := svc.ListBuckets(nil)
if err != nil {
exitErrorf("Unable to list buckets, %v", err)
}
fmt.Println("My buckets now are:\n")
for _, b := range result.Buckets {
fmt.Printf(aws.StringValue(b.Name) + "\n")
}
fmt.Printf("\n")
}
// Create a bucket in this AWS Region.
func createMyBucket(svc *s3.S3, bucketName string, region string) {
fmt.Printf("\nCreating a new bucket named '" + bucketName + "'...\n\n")
_, err := svc.CreateBucket(&s3.CreateBucketInput{
Bucket: aws.String(bucketName),
CreateBucketConfiguration: &s3.CreateBucketConfiguration{
LocationConstraint: aws.String(region),
},
})
if err != nil {
exitErrorf("Unable to create bucket, %v", err)
}
// Wait until bucket is created before finishing
fmt.Printf("Waiting for bucket %q to be created...\n", bucketName)
err = svc.WaitUntilBucketExists(&s3.HeadBucketInput{
Bucket: aws.String(bucketName),
})
}
// Delete the bucket you just created.
func deleteMyBucket(svc *s3.S3, bucketName string) {
fmt.Printf("\nDeleting the bucket named '" + bucketName + "'...\n\n")
_, err := svc.DeleteBucket(&s3.DeleteBucketInput{
Bucket: aws.String(bucketName),
})
if err != nil {
exitErrorf("Unable to delete bucket, %v", err)
}
// Wait until bucket is deleted before finishing
fmt.Printf("Waiting for bucket %q to be deleted...\n", bucketName)
err = svc.WaitUntilBucketNotExists(&s3.HeadBucketInput{
Bucket: aws.String(bucketName),
})
}
// If there's an error, display it.
func exitErrorf(msg string, args ...interface{}) {
fmt.Fprintf(os.Stderr, msg+"\n", args...)
os.Exit(1)
}
```
## 6단계: AWS SDK 코드 실행
1. AWS Cloud9 IDE의 메뉴 모음에서 **실행**, **실행 구성**, **새 실행 구성을** 선택합니다.
1. [**[새로 만들기] - 유휴([New] - Idle)**] 탭에서 [**러너: 자동(Runner: Auto)**]을 선택한 다음 [**Go**]를 선택합니다.
1. **명령**에를 입력합니다. `s3.go YOUR_BUCKET_NAME THE_AWS_REGION `여기서 ` YOUR_BUCKET_NAME `는 생성 및 삭제하려는 버킷의 이름이고 ` THE_AWS_REGION `는 버킷을 생성하려는 AWS 리전의 ID입니다. 예를 들어 미국 동부(오하이오) 리전의 경우 `us-east-2`를 사용합니다. 더 많은 ID는 **Amazon Web Services 일반 참조의 [Amazon Simple Storage Service(Amazon S3)](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region)를 참조하세요.
**참고**
Amazon S3 버킷 이름은 계정 AWS 뿐만 AWS아니라 여러 계정에서 고유해야 합니다.
1. **Run(실행)** 버튼을 선택하여 출력값을 비교합니다.
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## 7단계: 정리
이 샘플 사용을 완료한 후 AWS 계정에 지속적인 요금이 부과되지 않도록 하려면 환경을 삭제해야 합니다. 지침은 [에서 환경 삭제 AWS Cloud9](delete-environment.md) 단원을 참조하세요.
# 에 대한 TypeScript 자습서 AWS Cloud9
이 자습서에서는 AWS Cloud9 개발 환경에서 TypeScript를 사용하는 방법을 보여줍니다.
이 자습서를 따르고이 샘플을 생성하면 AWS 계정에 요금이 부과될 수 있습니다. 여기에는 Amazon EC2 및 Amazon S3 같은 서비스에 대한 발생할 수 있는 요금이 포함됩니다. 자세한 내용은 [Amazon EC2 요금](https://aws.amazon.com/ec2/pricing/) 및 [Amazon S3 요금](https://aws.amazon.com/s3/pricing/)을 참조하세요.
**Topics**
+ [사전 조건](#sample-typescript-prereqs)
+ [1단계: 필수 도구 설치](#sample-typescript-install)
+ [2단계: 코드 추가](#sample-typescript-code)
+ [3단계: 코드 실행](#sample-typescript-run)
+ [4단계: Node.js에서 JavaScript용 AWS SDK 설치 및 구성](#sample-typescript-sdk)
+ [5단계: AWS SDK 코드 추가](#sample-typescript-sdk-code)
+ [6단계: AWS SDK 코드 실행](#sample-typescript-sdk-run)
+ [7단계: 정리](#sample-typescript-clean-up)
## 사전 조건
이 샘플을 사용하기 전에 설정이 다음 요구 사항을 충족하는지 확인하세요.
+ **기존 AWS Cloud9 EC2 개발 환경이 있어야 합니다.** 이 샘플에서는 Amazon Linux 또는 Ubuntu 서버를 실행 중인 Amazon EC2 인스턴스에 연결된 EC2 환경이 이미 있다고 가정합니다. 다른 환경 또는 운영 시스템이라면 이 샘플 지침을 관련 도구를 설치하는 데에 적용해야 합니다. 자세한 내용은 [에서 환경 생성 AWS Cloud9](create-environment.md) 단원을 참조하십시오.
+ **기존 환경의 AWS Cloud9 IDE가 이미 열려 있습니다.** 환경을 열면가 웹 브라우저에서 해당 환경의 IDE를 AWS Cloud9 엽니다. 자세한 내용은 [에서 환경 열기 AWS Cloud9](open-environment.md) 단원을 참조하십시오.
## 1단계: 필수 도구 설치
이 단계에서는 Node Package Manager(**`npm`**)를 사용하여 TypeScript를 설치합니다. **`npm`**을 설치하려면 Node Version Manager(**`nvm`**)를 사용합니다. **`nvm`**이 없는 경우 이 단계에서 먼저 설치합니다.
1. IDE의 터미널 세션에서 ** `--version` ** 옵션을 사용하여 명령줄 TypeScript AWS Cloud9 컴파일러를 실행하여 TypeScript가 이미 설치되어 있는지 확인합니다. (터미널 세션을 새로 시작하려면 메뉴 모음에서 **Window(창)**, **New Terminal(새 터미널)**을 선택합니다.) 성공할 경우, 출력에 TypeScript 버전 번호가 포함됩니다. TypeScript가 설치된 경우 [2단계: 코드 추가](#sample-typescript-code) 단원으로 이동합니다.
```
tsc --version
```
1. ** `--version` ** 옵션을 지정하고 ** `npm` **을 실행하여 ** `npm` **이 이미 설치되어 있는지 확인합니다. 성공할 경우, 출력에** `npm` **버전 번호가 포함됩니다. **`npm`**이 설치된 경우 이 절차의 10단계로 건너뛰고 **`npm`**을 사용하여 TypeScript t를 설치합니다.
```
npm --version
```
1. **`yum update` **명령(Amazon Linux) 또는** `apt update` **명령(Ubuntu Server)을 실행하여 최신 보안 업데이트와 버그 수정이 설치되어 있는지 확인합니다.
Amazon Linux의 경우:
```
sudo yum -y update
```
Ubuntu Server:
```
sudo apt update
```
1. ** `npm` **을 설치하려면, 먼저 다음 명령을 실행하여 Node Version Manager(** `nvm` **)를 다운로드합니다. (** `nvm` **은 Node.js 버전을 설치하고 관리하는 데 유용한 간단한 Bash 셸 스크립트입니다. 자세한 내용은 GitHub 웹 사이트의 [Node Version Manager](https://github.com/creationix/nvm/blob/master/README.md)를 참조하세요.)
```
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.0/install.sh | bash
```
1. **`nvm`** 사용을 시작하려면 터미널 세션을 닫고 나서 다시 시작하거나, **`nvm`**을 로드하는 명령을 포함하는 `~/.bashrc` 파일을 소싱합니다.
```
. ~/.bashrc
```
1. ** `nvm` ** 옵션을 지정하고 ** `nvm` **을 실행하여 ** `--version` **이 설치되어 있는지 확인합니다.
```
nvm --version
```
1. **`nvm`**을 실행하여 최신 버전인 Node.js 16을 설치합니다(**`npm`**은 Node.js 에 포함되어 있음).
```
nvm install v16
```
1. **`--version` **옵션으로 명령줄 버전의 Node.js를 실행하여 Node.js가 설치되어 있는지 확인합니다.
```
node --version
```
1. ** `npm` ** 옵션을 지정하고 ** `npm` **을 실행하여 ** `--version` **이 설치되어 있는지 확인합니다.
```
npm --version
```
1. **`-g` **옵션으로 **`npm`**을 실행하여 TypeScript 설치합니다. 그러면 환경에 TypeScript가 글로벌 패키지로 설치됩니다.
```
npm install -g typescript
```
1. **`--version` **옵션으로 명령줄 TypeScript 컴파일러를 실행하여 TypeScript 가 설치되어 있는지 확인합니다.
```
tsc --version
```
## 2단계: 코드 추가
1. AWS Cloud9 IDE에서 라는 파일을 생성합니다`hello.ts`. (파일을 생성하려면 메뉴 모음에서 [**파일(File)**], [**새 파일(New File)**]을 선택합니다. 파일을 저장하려면 [**파일(File)**], [**저장(Save)**]을 선택합니다.)
1. IDE의 터미널에서, `hello.ts` 파일과 동일한 디렉터리에서** `npm`**을 실행하여 `@types/node` 라이브러리를 설치합니다.
```
npm install @types/node
```
그러면 `node_modules/@types/node` 파일과 동일한 디렉터리에 `hello.ts` 폴더가 추가됩니다. 이 새 폴더에는 이 절차의 뒷부분에서 `hello.ts` 파일에 추가할 `console.log` 및 `process.argv` 속성에 대해 TypeScript가 필요로 하는 Node.js 형식 정의가 포함되어 있습니다.
1. 다음 코드를 `hello.ts` 파일에 추가합니다:
```
console.log('Hello, World!');
console.log('The sum of 2 and 3 is 5.');
const sum: number = parseInt(process.argv[2], 10) + parseInt(process.argv[3], 10);
console.log('The sum of ' + process.argv[2] + ' and ' +
process.argv[3] + ' is ' + sum + '.');
```
## 3단계: 코드 실행
1. 터미널에서, `hello.ts` 파일과 동일한 디렉터리에서 TypeScript 컴파일러를 실행합니다. 포함할 `hello.ts` 파일 및 추가 라이브러리를 지정합니다.
```
tsc hello.ts --lib es6
```
TypeScript는 `hello.ts` 파일 및 ECMAScript 6(ES6) 라이브러리 파일 세트를 사용하여 `hello.ts` 파일의 TypeScript 코드를 `hello.js`라는 파일의 해당하는 JavaScript 코드로 변환합니다.
1. [**환경(Environment)**] 창에서 `hello.js` 파일을 엽니다.
1. 메뉴 표시줄에서 **실행**, **실행 구성**, **새 실행 구성**을 선택합니다.
1. [**[새로 만들기] - 유휴([New] - Idle)**] 탭에서 [**러너: 자동(Runner: Auto)**]을 선택한 다음 [**Node.js**]를 선택합니다.
1. **명령**에 `hello.js 5 9`를 입력합니다. 코드에서 `5`는 `process.argv[2]`를 나타내고 `9`는 `process.argv[3]`를 나타냅니다. (`process.argv[0]`는 런타임의 이름(`node`)을 나타내고 `process.argv[1]`는 파일의 이름(`hello.js`)을 나타냅니다.)
1. **Run(실행)**을 선택하여 출력을 비교합니다. 완료했으면 [**중지(Stop)**]를 선택합니다.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[AWS Cloud9 IDE에서 코드를 실행한 후 Node.js 출력\]](http://docs.aws.amazon.com/ko_kr/cloud9/latest/user-guide/images/ide-nodejs-simple.png)
**참고**
IDE에서 새 실행 구성을 생성하는 대신 터미널에서** `node hello.js 5 9` **명령을 실행하여 이 코드를 실행할 수도 있습니다.
## 4단계: Node.js에서 JavaScript용 AWS SDK 설치 및 구성
이 샘플을 개선하여 Node.js의 JavaScript용 AWS SDK를 사용하여 Amazon S3 버킷을 생성하고 사용 가능한 버킷을 나열한 다음 방금 생성한 버킷을 삭제할 수 있습니다.
이 단계에서는 Node.js에서 JavaScript용 AWS SDK를 설치하고 구성합니다. SDK는 JavaScript 코드에서 Amazon S3와 같은 AWS 서비스와 상호 작용하는 편리한 방법을 제공합니다. AWS SDK for JavaScript를 Node.js에 설치한 후에는 환경에서 자격 증명 관리를 설정해야 합니다. SDK가 AWS 서비스와 상호 작용하려면 이러한 자격 증명이 필요합니다.
### AWS SDK for JavaScript를 Node.js에 설치하려면
IDE의 터미널 세션에서 AWS Cloud9 의 `hello.js` 파일과 동일한 디렉터리에서를 [3단계: 코드 실행](#sample-typescript-run)실행**`npm`**하여 AWS SDK for JavaScript를 Node.js에 설치합니다.
```
npm install aws-sdk
```
이 명령은 [3단계: 코드 실행](#sample-typescript-run)의 `node_modules` 폴더에 여러 폴더를 추가합니다. 이러한 폴더에는 Node.js의 JavaScript용 AWS SDK에 대한 소스 코드와 종속성이 포함되어 있습니다. 자세한 내용은 *AWS SDK for JavaScript 개발자 가이드*에서 [SDK for JavaScript 설치](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/installing-jssdk.html)를 참조하세요.
### 환경에서 보안 인증 관리를 설정하려면
Node.js의 JavaScript용 AWS SDK를 사용하여 AWS 서비스를 호출할 때마다 호출과 함께 자격 증명 세트를 제공해야 합니다. 이러한 자격 증명은 Node.js의 JavaScript용 AWS SDK에 해당 호출을 수행할 수 있는 적절한 권한이 있는지 여부를 결정합니다. 자격 증명으로 적절한 권한이 확인되지 않는 경우 호출이 실패합니다.
이 단계에서는 환경 내에서 자격 증명을 저장합니다. 이렇게 하려면 [AWS 서비스 의 환경에서 호출 AWS Cloud9](credentials.md) 섹션의 지침을 수행한 다음 이 주제로 돌아옵니다.
자세한 내용은 *AWS SDK for JavaScript 개발자 가이드*의 [Node.js에서 자격 증명 설정](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html)을 참조하세요.
## 5단계: AWS SDK 코드 추가
이 단계에서는 몇 가지 코드를 더 추가합니다. 이번 경우에는 Amazon S3와 상호 작용하기 위한 것이며 버킷을 생성하고 사용 가능한 버킷을 나열한 다음 막 생성한 버킷을 삭제합니다. 이 코드를 나중에 실행합니다.
1. AWS Cloud9 IDE에서 이전 단계의 `hello.js` 파일과 동일한 디렉터리에 라는 파일을 생성합니다`s3.ts`.
1. AWS Cloud9 IDE의 터미널에서 `s3.ts` 파일과 동일한 디렉터리에서 두 ** `npm` ** 번 실행하여 TypeScript용 비동기 라이브러리를 설치하고 JavaScript용 비동기 라이브러리를 다시 실행하여 Amazon S3 작업을 비동기적으로 호출하도록 코드를 활성화합니다.
```
npm install @types/async # For TypeScript.
npm install async # For JavaScript.
```
1. 다음 코드를 `s3.ts` 파일에 추가합니다:
```
import * as async from 'async';
import * as AWS from 'aws-sdk';
if (process.argv.length < 4) {
console.log('Usage: node s3.js \n' +
'Example: node s3.js my-test-bucket us-east-2');
process.exit(1);
}
const AWS = require('aws-sdk'); // To set the AWS credentials and AWS Region.
const async = require('async'); // To call AWS operations asynchronously.
const s3: AWS.S3 = new AWS.S3({apiVersion: '2006-03-01'});
const bucket_name: string = process.argv[2];
const region: string = process.argv[3];
AWS.config.update({
region: region
});
const create_bucket_params: any = {
Bucket: bucket_name,
CreateBucketConfiguration: {
LocationConstraint: region
}
};
const delete_bucket_params: any = {
Bucket: bucket_name
};
// List all of your available buckets in this AWS Region.
function listMyBuckets(callback): void {
s3.listBuckets(function(err, data) {
if (err) {
} else {
console.log("My buckets now are:\n");
for (let i: number = 0; i < data.Buckets.length; i++) {
console.log(data.Buckets[i].Name);
}
}
callback(err);
});
}
// Create a bucket in this AWS Region.
function createMyBucket(callback): void {
console.log("\nCreating a bucket named '" + bucket_name + "'...\n");
s3.createBucket(create_bucket_params, function(err, data) {
if (err) {
console.log(err.code + ": " + err.message);
}
callback(err);
});
}
// Delete the bucket you just created.
function deleteMyBucket(callback): void {
console.log("\nDeleting the bucket named '" + bucket_name + "'...\n");
s3.deleteBucket(delete_bucket_params, function(err, data) {
if (err) {
console.log(err.code + ": " + err.message);
}
callback(err);
});
}
// Call the AWS operations in the following order.
async.series([
listMyBuckets,
createMyBucket,
listMyBuckets,
deleteMyBucket,
listMyBuckets
]);
```
## 6단계: AWS SDK 코드 실행
1. 터미널에서, `s3.ts` 파일과 동일한 디렉터리에서 TypeScript 컴파일러를 실행합니다. 포함할 `s3.ts` 파일 및 추가 라이브러리를 지정합니다.
```
tsc s3.ts --lib es6
```
TypeScript는 `s3.ts` 파일, Node.js의 JavaScript용 AWS SDK, 비동기 라이브러리 및 ECMAScript 6(ES6) 라이브러리 파일 세트를 사용하여 `s3.ts` 파일의 TypeScript 코드를 라는 파일의 동등한 JavaScript 코드로 트랜스파일합니다`s3.js`.
1. [**환경(Environment)**] 창에서 `s3.js` 파일을 엽니다.
1. 메뉴 표시줄에서 **실행**, **실행 구성**, **새 실행 구성**을 선택합니다.
1. [**[새로 만들기] - 유휴([New] - Idle)**] 탭에서 [**러너: 자동(Runner: Auto)**]을 선택한 다음 [**Node.js**]를 선택합니다.
1. **명령**에를 입력합니다. `s3.js YOUR_BUCKET_NAME THE_AWS_REGION `여기서 ` YOUR_BUCKET_NAME `는 생성 및 삭제하려는 버킷의 이름이고 ` THE_AWS_REGION `는 버킷을 생성할 AWS 리전의 ID입니다. 예를 들어 미국 동부(오하이오) 리전의 경우 `us-east-2`를 사용합니다. 더 많은 ID는 **Amazon Web Services 일반 참조의 [Amazon Simple Storage Service(Amazon S3)](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region)를 참조하세요.
**참고**
Amazon S3 버킷 이름은 계정 AWS 뿐만 AWS아니라 여러 계정에서 고유해야 합니다.
1. **Run(실행)**을 선택하여 출력을 비교합니다. 완료했으면 [**중지(Stop)**]를 선택합니다.
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## 7단계: 정리
이 샘플 사용을 완료한 후 AWS 계정에 지속적인 요금이 부과되지 않도록 하려면 환경을 삭제해야 합니다. 지침은 [에서 환경 삭제 AWS Cloud9](delete-environment.md) 단원을 참조하세요.
# 에 대한 Docker 자습서 AWS Cloud9
이 자습서에서는 AWS Cloud9 SSH 개발 환경을 Amazon EC2의 Amazon Linux 인스턴스 내에서 실행 중인 Docker 컨테이너에 연결하는 방법을 보여줍니다. 이를 통해 AWS Cloud9 IDE를 사용하여 Docker 컨테이너 내부의 코드 및 파일로 작업하고 해당 컨테이너에서 명령을 실행할 수 있습니다. 도커에 대한 자세한 내용은 도커 웹 사이트의 [도커란 무엇인가?](https://www.docker.com/what-docker)를 참조하십시오.
이 자습서를 따르고이 샘플을 생성하면 AWS 계정에 요금이 부과될 수 있습니다. 여기에는 Amazon EC2와 같은 서비스에 대해 발생할 수 있는 요금이 포함됩니다. 자세한 내용은 [Amazon EC2 요금](https://aws.amazon.com/ec2/pricing/)을 참조하세요.
**Topics**
+ [사전 조건](#sample-docker-prereqs)
+ [1단계: Docker 설치 및 실행](#sample-docker-install)
+ [2단계: 이미지 빌드](#sample-docker-build)
+ [3단계: 컨테이너 실행](#sample-docker-run)
+ [4단계: 환경 생성](#sample-docker-env)
+ [5단계: 코드 실행](#sample-docker-code)
+ [6단계: 정리](#sample-docker-clean-up)
## 사전 조건
+ **Amazon Linux 또는 Ubuntu Server를 실행 중인 Amazon EC2 인스턴스가 있어야 합니다.** 이 샘플에서는 AWS 계정에 Amazon Linux 또는 Ubuntu Server를 실행하는 Amazon EC2 인스턴스가 이미 있다고 가정합니다. Amazon EC2 인스턴스를 시작하려면 [Linux 가상 머신 시작](https://aws.amazon.com/getting-started/tutorials/launch-a-virtual-machine/)을 참조하세요. 마법사의 [**Amazon 머신 이미지(AMI) 선택(Choose an Amazon Machine Image (AMI))**] 페이지에서 표시 이름이 **Amazon Linux AMI** 또는 **Ubuntu Server**로 시작하는 AMI를 선택합니다.
+ **Amazon EC2 인스턴스가 Amazon VPC에서 실행되는 경우 추가 요구 사항이 수반됩니다.** [AWS Cloud9 개발 환경에 대한 VPC 설정](vpc-settings.md)을(를) 참조하세요.
+ **Amazon EC2 인스턴스에 사용 가능한 디스크 공간이 8\$116GB 이상 있어야 합니다.** 이 샘플은 크기가 3GB를 초과하는 도커 이미지를 사용하며 추가 증분량이 3GB 이상인 디스크 공간을 사용하여 이미지를 빌드할 수 있습니다. 사용 가능한 공간이 8GB 미만인 디스크에서 이 샘플을 실행하려 할 경우 도커 이미지를 빌드할 수 없거나 도커 컨테이너가 실행되지 않을 것입니다. 인스턴스의 사용 가능한 디스크 공간을 확인하려면 인스턴스에서 ** `df -h`**("인간 판독 가능한 형식의 디스크 파일 시스템 정보")와 같은 명령을 실행할 수 있습니다. 기존 인스턴스의 디스크 크기를 늘리려면 *Amazon EC2 사용 설명서*의 [볼륨 수정](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-modify-volume.html)을 참조하세요.
## 1단계: Docker 설치 및 실행
이 단계에서는 Docker가 Amazon EC2 인스턴스에 설치되어 있는지 여부를 확인하고 아직 설치되지 않은 경우 Docker를 설치합니다. 도커를 설치한 후에는 인스턴스에서 도커를 실행합니다.
1. **`ssh` **유틸리티 또는 PuTTY와 같은 SSH 클라이언트를 사용하여 실행 중인 Amazon EC2 인스턴스에 연결합니다. 이렇게 하려면 [Linux 가상 머신 시작](https://aws.amazon.com/getting-started/tutorials/launch-a-virtual-machine/)에서 "3단계: 인스턴스에 연결"을 참조하십시오.
1. 도커가 인스턴스에 설치되었는지 확인합니다. 이렇게 하려면** `--version` **옵션을 사용하여 인스턴스에 대해** `docker` **명령을 실행합니다.
```
docker --version
```
도커가 설치되면 도커 버전과 빌드 번호가 표시됩니다. 이 경우, 이 절차의 뒷부분인 5단계로 이동합니다.
1. 도커를 설치합니다. 이렇게 하려면 설치할 ** `docker` ** 또는 ** `docker.io` ** 패키지를 지정하고 ** `install` ** 작업을 사용하여 ** `yum` ** 또는 ** `apt` ** 명령을 실행합니다.
Amazon Linux의 경우:
```
sudo yum install -y docker
```
Ubuntu Server:
```
sudo apt install -y docker.io
```
1. 도커가 설치되었는지 확인합니다. 이렇게 하려면 ** `docker --version` ** 명령을 다시 실행합니다. 도커 버전 및 빌드 번호가 표시됩니다.
1. 도커를 실행합니다. 이렇게 하려면 ** `docker` ** 서비스와 ** `start` ** 작업을 사용하여 ** `service` ** 명령을 실행합니다.
```
sudo service docker start
```
1. 도커가 실행 중인지 확인합니다. 이렇게 하려면** `info` **작업을 사용하여** `docker` **명령을 실행합니다.
```
sudo docker info
```
도커를 실행 중인 경우 도커에 대한 정보가 표시됩니다.
## 2단계: 이미지 빌드
이 단계에서 Dockerfile을 사용하여 도커 이미지를 인스턴스에 빌드합니다. 이 샘플에서는 Node.js와 샘플 채팅 서버 애플리케이션을 포함하는 이미지를 사용합니다.
1. 인스턴스에서 Dockerfile을 생성합니다. 이렇게 하려면 인스턴스의 `/tmp` 디렉터리에서 인스턴스에 여전히 연결되어 있는 SSH 클라이언트를 사용하여 `Dockerfile` 이름의 파일을 생성합니다. 예를 들면 다음과 같이 **`touch`** 명령을 실행합니다.
```
sudo touch /tmp/Dockerfile
```
1. 다음 내용을 `Dockerfile` 파일에 추가합니다.
```
# Build a Docker image based on the Amazon Linux 2 Docker image.
FROM amazonlinux:2
# install common tools
RUN yum install -y https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
RUN yum update -y
RUN yum install -y sudo bash curl wget git man-db nano vim bash-completion tmux gcc gcc-c++ make tar
# Enable the Docker container to communicate with AWS Cloud9 by
# installing SSH.
RUN yum install -y openssh-server
# Ensure that Node.js is installed.
RUN yum install -y nodejs
# Create user and enable root access
RUN useradd --uid 1000 --shell /bin/bash -m --home-dir /home/ubuntu ubuntu && \
sed -i 's/%wheel\s.*/%wheel ALL=NOPASSWD:ALL/' /etc/sudoers && \
usermod -a -G wheel ubuntu
# Add the AWS Cloud9 SSH public key to the Docker container.
# This assumes a file named authorized_keys containing the
# AWS Cloud9 SSH public key already exists in the same
# directory as the Dockerfile.
RUN mkdir -p /home/ubuntu/.ssh
ADD ./authorized_keys /home/ubuntu/.ssh/authorized_keys
RUN chown -R ubuntu /home/ubuntu/.ssh /home/ubuntu/.ssh/authorized_keys && \
chmod 700 /home/ubuntu/.ssh && \
chmod 600 /home/ubuntu/.ssh/authorized_keys
# Update the password to a random one for the user ubuntu.
RUN echo "ubuntu:$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 32 | head -n 1)" | chpasswd
# pre-install Cloud9 dependencies
USER ubuntu
RUN curl https://d2j6vhu5uywtq3.cloudfront.net/static/c9-install.sh | bash
USER root
# Start SSH in the Docker container.
CMD ssh-keygen -A && /usr/sbin/sshd -D
```
앞의 내용을 `Dockerfile` 파일에 추가하려면 다음과 같이 인스턴스에서 **`vi`** 유틸리티를 사용할 수 있습니다.
1. AWS Cloud9 를 사용하여 `/tmp/Dockerfile` 파일을 열고 편집합니다.
```
sudo vi /tmp/Dockerfile
```
1. 앞의 내용을 `Dockerfile` 파일에 붙여 넣습니다. 이 동작을 수행하는 방법을 잘 모르는 경우 SSH 클라이언트 설명서를 참조하십시오.
1. 명령 모드로 전환합니다. 이렇게 하려면 `Esc` 키를 누릅니다. 그러면 `-- INSERT --`가 창의 하단에서 사라집니다.
1. `:wq`를 입력하여 `/tmp/Dockerfile` 파일에 쓰고 나서 파일을 저장한 다음 **`vi`**를 종료한 후, `Enter`를 누릅니다.
**참고**
자주 업데이트되는 Docker 이미지 목록에 액세스할 수 있습니다 AWS CodeBuild. 자세한 내용은 *AWS CodeBuild 사용 설명서*에서 [CodeBuild에서 제공하는 Docker 이미지](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-available.html)를 참조하세요.
1. 인스턴스에서 사용할 Docker 컨테이너에 대한 AWS Cloud9 SSH 퍼블릭 키가 포함된 파일을 생성합니다. 이렇게 하려면 예를 들어** `touch` **명령을 실행하여 `Dockerfile` 파일과 같은 디렉터리에 이름이 `authorized_keys`인 파일을 생성합니다.
```
sudo touch /tmp/authorized_keys
```
1. `authorized_keys` 파일에 AWS Cloud9 SSH 퍼블릭 키를 추가합니다. AWS Cloud9 SSH 퍼블릭 키를 가져오려면 다음을 수행합니다.
1. [https://console.aws.amazon.com/cloud9/](https://console.aws.amazon.com/cloud9/) AWS Cloud9 콘솔을 엽니다.
1. AWS 탐색 모음의 AWS 리전 선택기에서이 주제의 뒷부분에서 AWS Cloud9 개발 환경을 생성할 AWS 리전을 선택합니다.
1. 시작 페이지가 표시되면 **새 AWS Cloud9 환경에서** **환경 생성을** 선택합니다. 그렇지 않으면 **Create environment**(환경 생성)를 선택합니다.
1. [**환경 이름 지정(Name environment)**] 페이지의 [**이름(Name)**]에 환경의 이름을 입력합니다. (여기서는 이름이 중요하지 않습니다. 나중에 다른 이름을 선택할 수 있습니다.)
1. **다음 단계**를 선택합니다.
1. **Environment type(환경 유형)**에서 **Connect and run in remote server(SSH)(원격 서버에서 연결 및 실행(SSH))**를 선택합니다.
1. **View public SSH key(퍼블릭 SSH 키 보기)**를 확장합니다.
1. **Copy key to clipboard(클립보드에 키 복사)**를 선택합니다. (이 항목은 **View public SSH key(퍼블릭 SSH 키 보기)** 및 **Advanced settings(고급 설정)** 사이에 있습니다.)
1. **취소**를 선택합니다.
1. 클립보드의 내용을 `authorized_keys` 파일에 붙여 넣고 나서 파일을 저장합니다. 예를 들어 이 단계의 앞부분에서 설명한 대로 **`vi`** 유틸리티를 사용할 수 있습니다.
1. ** `build` ** 작업을 사용하고 `cloud9-image:latest` 태그를 이미지에 추가하고 사용할 `Dockerfile` 파일의 경로를 지정하여 ** `docker` ** 명령을 실행함으로써 이미지를 빌드합니다.
```
sudo docker build -t cloud9-image:latest /tmp
```
명령이 성공적으로 실행되면 빌드 출력의 마지막 두 줄에 `Successfully built` 및 `Successfully tagged`가 표시됩니다.
Docker가 이미지를 성공적으로 빌드했는지 확인하려면 `image ls` 작업을 사용하여** `docker` **명령을 실행합니다.
```
sudo docker image ls
```
명령이 성공적으로 실행되면 출력 디스플레이에 항목 하나가 표시됩니다. 이 항목에서 `REPOSITORY` 필드는 `cloud9-image`로 설정되었으며 `TAG` 필드는 `latest`로 설정되었습니다.
1. Amazon EC2 인스턴스의 퍼블릭 IP 주소를 적어둡니다. [4단계: 환경 생성](#sample-docker-env)에 필요한 정보입니다. 인스턴스의 퍼블릭 IP 주소를 잘 모르는 경우 인스턴스에서 다음 명령을 실행하여 해당 주소를 가져올 수 있습니다.
```
curl http://169.254.169.254/latest/meta-data/public-ipv4
```
## 3단계: 컨테이너 실행
이 단계에서는 인스턴스에서 도커 컨테이너를 실행합니다. 이 컨테이너는 이전 단계에서 빌드한 이미지에 기초합니다.
1. Docker 컨테이너를 실행하려면** `run` **작업과 다음 옵션을 사용하여 인스턴스에 대해** `docker` **명령을 실행합니다.
```
sudo docker run -d -it --expose 9090 -p 0.0.0.0:9090:22 --name cloud9 cloud9-image:latest
```
+ `-d`는 컨테이너를 분리 모드로 실행하고 컨테이너(이 샘플에서는 SSH 클라이언트)를 실행하는 데 사용되는 루트 프로세스가 종료될 때마다 종료합니다.
+ `-it`는 의사 TTY가 할당된 컨테이너를 실행하고 컨테이너가 연결되지 않았어도 STDIN을 열린 상태로 유지합니다.
+ `--expose`는 지정한 포트(이 샘플에서는 `9090`)를 컨테이너에서 사용할 수 있도록 설정합니다.
+ `-p`는 지정한 IP 주소 및 포트를 통해 지정한 포트를 Amazon EC2 인스턴스 내부에서 사용할 수 있도록 설정합니다. 이 샘플에서 컨테이너의 포트 `9090`은 Amazon EC2 인스턴스의 포트 `22`를 통해 내부에서 액세스할 수 있습니다.
+ `--name`은 컨테이너용 인간이 읽을 수 있는 이름(이 샘플에서는 `cloud9`)입니다.
+ `cloud9-image:latest`는 컨테이너를 실행하는 데 사용할 빌드된 이미지의 인간이 읽을 수 있는 이름입니다.
Docker가 컨테이너를 성공적으로 실행하고 있는지 확인하려면 `container ls` 작업을 사용하여** `docker` **명령을 실행합니다.
```
sudo docker container ls
```
명령이 성공적으로 실행되면 출력 디스플레이에 항목 하나가 표시됩니다. 이 항목에서 `IMAGE` 필드는 `cloud9-image:latest`로 설정되었으며 `NAMES` 필드는 `cloud9`로 설정되었습니다.
1. 실행 중인 컨테이너에 로그인합니다. 이렇게 하려면** `exec` **작업과 다음 옵션을 사용하여** `docker` **명령을 실행합니다.
```
sudo docker exec -it cloud9 bash
```
+ `-it`는 의사 TTY가 할당된 컨테이너를 실행하고 컨테이너가 연결되지 않았어도 STDIN을 열린 상태로 유지합니다.
+ `cloud9`는 실행 중인 컨테이너의 인간이 읽을 수 있는 이름입니다.
+ `bash`는 실행 중인 컨테이너에서 표준 셸을 시작합니다.
성공할 경우 터미널 프롬프트가 변경되어 컨테이너의 로그인된 사용자 이름과 컨테이너의 ID를 표시합니다.
**참고**
실행 중인 컨테이너에서 로그아웃하려면 **`exit`** 명령을 실행합니다. 터미널 프롬프트가 다시 변경되어 인스턴스의 로그인된 사용자 이름과 인스턴스의 프라이빗 DNS를 표시합니다. 컨테이너가 여전히 실행 중이어야 합니다.
1. 로그인 후 시작 AWS Cloud9 하려는 실행 중인 컨테이너의 디렉터리에 대해 액세스 권한을 ** `rwxr-xr-x` **로 설정합니다. 다시 말해서 소유자에게는 읽기/쓰기/실행 권한, 그룹에는 읽기/실행 권한, 그리고 그 밖의 사람에게는 읽기/실행 권한이 부여됩니다. 예를 들어 디렉터리의 경로가 `~`인 경우 다음과 같이 실행 중인 컨테이너에서 **`chmod`** 명령을 실행하여 디렉터리에서 이러한 권한을 설정할 수 있습니다.
```
sudo chmod u=rwx,g=rx,o=rx ~
```
1. Node.js 바이너리를 포함하는 실행 중인 컨테이너의 디렉터리에 대한 경로를 적어둡니다. 이 경로는 [4단계: 환경 생성](#sample-docker-env)에 필요합니다. 이 경로를 잘 모르면 실행 중인 컨테이너에서 다음 명령을 실행하여 가져옵니다.
```
which node
```
## 4단계: 환경 생성
이 단계에서는 AWS Cloud9 를 사용하여 AWS Cloud9 SSH 개발 환경을 생성하고 이를 실행 중인 Docker 컨테이너에 연결합니다. 가 환경을 AWS Cloud9 생성하면 컨테이너의 파일 및 코드 작업을 시작할 수 있도록 AWS Cloud9 IDE가 표시됩니다.
AWS Cloud9 콘솔을 사용하여 AWS Cloud9 SSH 개발 환경을 생성합니다. CLI를 사용하여 SSH 환경을 만들 수는 없습니다.
### 사전 조건
+ 먼저 [설 AWS Cloud9정](setting-up.md)의 단계를 완료했는지 확인합니다. 이렇게 해야 AWS Cloud9 콘솔에 로그인하여 환경을 생성할 수 있습니다.
+ 환경에 연결 AWS Cloud9 하려는 기존 클라우드 컴퓨팅 인스턴스(예:의 Amazon EC2 인스턴스 AWS 계정) 또는 자체 서버를 식별합니다.
+ 기존 인스턴스 또는 자체 서버가 모든 [SSH 호스트 요구 사항](ssh-settings.md#ssh-settings-requirements)을 충족해야 합니다. 이러한 요구 사항에는 특정 버전의 Python, Node.js 및 기타 구성 요소 설치, 로그인 후 AWS Cloud9 이 시작하도록 할 디렉터리에 대한 특정 권한 설정, 연결된 Amazon Virtual Private Cloud 설정이 포함됩니다.
### SSH 환경 생성
1. 위의 사전 조건을 완료해야 합니다.
1. 아직 연결되지 않은 경우 SSH 클라이언트를 사용하여 기존 인스턴스 또는 자체 서버에 연결합니다. 이렇게 하면 필요한 공개 SSH 키 값을 인스턴스나 서버에 추가할 수 있습니다. 이 절차의 뒷부분에서 자세하게 설명합니다.
**참고**
기존 AWS 클라우드 컴퓨팅 인스턴스에 연결하려면 다음 리소스 중 하나 이상을 참조하세요.
Amazon EC2의 경우 *Amazon EC2 사용 설명서*에서 [Linux 인스턴스에 연결](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instance.html)을 참조하세요.
Amazon Lightsail에 대해서는 **Amazon Lightsail 설명서의 [Linux/UNIX 기반 Lightsail 인스턴스에 연결](https://lightsail.aws.amazon.com/ls/docs/how-to/article/lightsail-how-to-connect-to-your-instance-virtual-private-server)을 참조하세요.
자세한 AWS Elastic Beanstalk내용은 *AWS Elastic Beanstalk 개발자 안내서*의 [서버 인스턴스 나열 및 연결을 참조하세요](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/using-features.ec2connect.html).
의 경우 *AWS OpsWorks 사용 설명서*의 [SSH를 사용하여 Linux 인스턴스에 로그인](https://docs.aws.amazon.com/opsworks/latest/userguide/workinginstances-ssh.html)을 AWS OpsWorks참조하세요.
기타 정보는 해당 특정 서비스에 대한 설명서를 AWS 서비스참조하세요.
자체 서버에 연결하려면 SSH를 사용하세요. SSH는 macOS 및 Linux 운영 체제에서는 이미 설치되어 있습니다. 윈도우에서 SSH를 사용하여 서버에 연결하려면 [PuTTY](https://www.putty.org/)를 설치해야 합니다.
1. [https://console.aws.amazon.com/cloud9/](https://console.aws.amazon.com/cloud9/) AWS Cloud9 콘솔에 로그인합니다.
1. AWS Cloud9 콘솔에 로그인한 후 상단 탐색 모음에서 환경을 생성할 AWS 리전 를 선택합니다. 사용 가능한 목록은의 섹션을 AWS 리전참조[AWS Cloud9](https://docs.aws.amazon.com/general/latest/gr/rande.html#cloud9_region)하세요*AWS 일반 참조*.
![\[AWS Cloud9 콘솔의 리전 선택기\]](http://docs.aws.amazon.com/ko_kr/cloud9/latest/user-guide/images/consolas_region_new_UX.png)
1. 개발 환경을 처음 생성하는 경우 시작 페이지가 표시됩니다. **새 AWS Cloud9 환경** 패널에서 **환경 생성을** 선택합니다.
이전에 개발 환경을 생성한 경우 화면 왼쪽의 창을 확장합니다. **Your environments**(사용자 환경)를 선택하고 **Create environment**(환경 생성)를 선택합니다.
**시작** 페이지에서:
![\[시작 페이지가 표시되면 Create environment(환경 생성) 버튼 선택\]](http://docs.aws.amazon.com/ko_kr/cloud9/latest/user-guide/images/create_welcome_env_new_UX.png)
또는 **Your environments**(환경) 페이지에서:
![\[시작 페이지가 표시되지 않으면 Create environment(환경 생성) 버튼 선택\]](http://docs.aws.amazon.com/ko_kr/cloud9/latest/user-guide/images/console_create_env_new_UX.png)
1. **Create environment(환경 생성)** 페이지에 환경의 이름을 입력합니다.
1. **Description**(설명)에 환경에 대한 설명을 입력합니다. 본 자습서에서는 `This environment is for the AWS Cloud9 tutorial.`을 사용합니다.
1. **Environment type**(환경 유형)에서는 다음 옵션 중에서 **Existing Compute**(기존 컴퓨팅)를 선택합니다.
+ **새 EC2 인스턴스** - SSH를 통해 직접에 연결할 AWS Cloud9 수 있는 Amazon EC2 인스턴스를 시작합니다.
+ ** 기존 컴퓨팅 ** - 열린 인바운드 포트가 필요하지 않은 Amazon EC2 인스턴스를 시작합니다.는를 통해 인스턴스에 AWS Cloud9 연결합니다[AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager.html).
+ **Existing compute**(기존 컴퓨팅) 옵션을 선택하면 Systems Manager가 사용자를 대신하여 EC2 인스턴스와 상호 작용할 수 있도록 서비스 역할과 IAM 인스턴스 프로파일이 생성됩니다. 인터페이스의 더 아래에 있는 **Service role and instance profile for Systems Manager access**(Systems Manager 액세스를 위한 서비스 역할 및 인스턴스 프로파일) 섹션에서 서비스 역할과 인스턴스 프로파일의 이름을 모두 확인할 수 있습니다. 자세한 내용은 [를 사용하여 수신하지 않는 EC2 인스턴스에 액세스 AWS Systems Manager](ec2-ssm.md) 단원을 참조하십시오.
**주의**
환경에 대한 EC2 인스턴스를 생성하면 Amazon EC2 AWS 계정 에 대한 요금이에 부과될 수 있습니다. Systems Manager를 사용하여 EC2 인스턴스에 대한 연결을 관리하는 데 따른 추가 비용은 없습니다.
**주의**
AWS Cloud9 는 SSH 퍼블릭 키를 사용하여 서버에 안전하게 연결합니다. 보안 연결을 설정하려면 다음 단계에서 공개 키를 `~/.ssh/authorized_keys` 파일에 추가하고 로그인 보안 인증 정보를 제공하십시오. **Copy key to clipboard**(클립보드에 키 복사)를 선택하여 SSH 키를 복사하거나, **View public SSH key**(공개 SSH 키 보기)를 선택하여 키를 표시합니다.
1. **Existing compute**(기존 컴퓨팅) 패널의 **User**(사용자)에 이 절차의 앞부분에서 인스턴스 또는 서버에 연결하는 데 사용한 로그인 이름을 입력합니다. 예를 들어 AWS 클라우드 컴퓨팅 인스턴스의 경우 이 값은 `ec2-user`, `ubuntu` 또는 `root`일 수 있습니다.
**참고**
로그인 이름이 인스턴스 또는 서버의 관리 권한 또는 관리자 사용자와 연결되는 것이 좋습니다. 더 자세히 말하자면, 이 로그인 이름은 인스턴스 또는 서버에서 Node.js 설치를 소유하는 것이 좋습니다. 이를 확인하려면 인스턴스 또는 서버의 터미널에서 ** `ls -l $(which node)` **(또는 `nvm`을 사용하는 경우 ** `ls -l $(nvm which node)` **) 명령을 실행합니다. 이 명령은 Node.js 설치의 소유자 이름을 표시합니다. 설치의 권한, 그룹 이름과 위치도 표시합니다.
1. **Host**(호스트)에 인스턴스 또는 서버의 퍼블릭 IP 주소(기본) 또는 호스트 이름을 입력합니다.
1. **포트에** 인스턴스 또는 서버에 연결하기 위해 AWS Cloud9 사용할 포트를 입력합니다. 또는 기본 포트를 그대로 유지합니다.
1. **Additional details - optional**(추가 상세 정보 - 선택 사항)을 선택하여 환경 경로, node.js 바이너리 경로 및 SSH 점프 호스트 정보를 표시합니다.
1. **환경 경로**에 시작 AWS Cloud9 하려는 인스턴스 또는 서버의 디렉터리 경로를 입력합니다. 이 절차의 사전 요구 사항에서 이를 이미 확인했습니다. 이 항목을 비워 두면 AWS Cloud9 은 로그인 후 인스턴스 또는 서버가 일반적으로 시작되는 디렉터리를 사용합니다. 이 디렉터리는 일반적으로 홈 또는 기본 디렉터리입니다.
1. **Path to Node.js binary path**(Node.js 바이너리 경로로 가는 경로)에 경로 정보를 입력하여, 인스턴스 또는 서버의 Node.js 바이너리로 가는 경로를 지정합니다. 경로를 가져오려면 인스턴스 또는 서버에서 **`which node`**(또는 `nvm`을 사용하는 경우 ** `nvm which node` **) 명령을 실행할 수 있습니다. 예를 들어 이 경로는 `/usr/bin/node`일 수 있습니다. 이 항목을 비워 두면 AWS Cloud9 은 연결을 시도할 때 Node.js 바이너리의 위치를 추측합니다.
1. **SSH jump host**(SSH 점프 호스트)에 인스턴스 또는 서버가 사용하는 점프 호스트에 대한 정보를 입력합니다. 형식 `USER_NAME@HOSTNAME:PORT_NUMBER`(예:`ec2-user@:ip-192-0-2-0:22`)를 사용합니다.
점프 호스트는 다음 요구 사항을 충족해야 합니다.
+ SSH를 사용하여 퍼블릭 인터넷을 통해 접근 가능해야 합니다.
+ 지정된 포트를 통해 어떤 IP 주소에서든 인바운드 액세스를 허용해야 합니다.
+ 기존 인스턴스 또는 서버의 `~/.ssh/authorized_keys` 파일에 복사된 퍼블릭 SSH 키 값을 점프 호스트의 `~/.ssh/authorized_keys` 파일에도 복사해야 합니다.
+ Netcat이 설치되어 있어야 합니다.
1. 각 태그에 **키**와 **값**을 지정하여 최대 50개의 태그를 추가합니다. **Add new tag**(새 태그 추가)를 선택하면 됩니다. 태그는 리소스 태그로 AWS Cloud9 환경에 연결되며 CloudFormation 스택, Amazon EC2 인스턴스 및 Amazon EC2 보안 그룹의 기본 리소스로 전파됩니다. 태그에 대한 자세한 내용은 *[IAM 사용 설명서](https://docs.aws.amazon.com/IAM/latest/UserGuide/)*의 [AWS 리소스 태그를 사용한 액세스 제어](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html) 및이 설명서의 태그에 대한 [고급 정보를](tags.md) 참조하세요.
**주의**
태그를 생성한 후 이러한 태그를 업데이트하면 변경 사항이 기본 리소스에 전파되지 않습니다. 자세한 내용은 [태그](tags.md)에 대한 고급 정보에서 [기본 리소스에 태그 업데이트 전파](tags.md#tags-propagate) 섹션을 참조하세요.
1. **Create**(생성)를 선택하여 환경을 만들면 홈 페이지로 리디렉션됩니다. 계정이 성공적으로 생성되면 AWS Cloud9 콘솔 상단에 녹색 플래시 바가 나타납니다. 새 환경을 선택하고 **Open in Cloud9**(Cloud9에서 열기)을 선택하여 IDE를 시작할 수 있습니다.
![\[AWS Cloud9 AWS Cloud9 콘솔의 IDE 선택기\]](http://docs.aws.amazon.com/ko_kr/cloud9/latest/user-guide/images/cloud9-ide-open.png)
계정이 생성되지 못하면 AWS Cloud9 콘솔 상단에 적색 플래시바가 나타납니다. 웹 브라우저, AWS 액세스 권한, 인스턴스 또는 연결된 네트워크의 문제로 인해 계정이 생성되지 않을 수 있습니다. 계정 장애를 일으킬 수 있는 문제를 해결하는 방법 관련 정보는 [AWS Cloud9 문제 해결 섹션](troubleshooting.md#troubleshooting-env-loading)에서 확인할 수 있습니다.
**참고**
환경에서 프록시를 사용하여 인터넷에 액세스하는 경우 종속성을 설치할 수 AWS Cloud9 있도록에 프록시 세부 정보를 제공해야 합니다. 자세한 내용은 [종속성을 설치하지 못함](troubleshooting.md#proxy-failed-dependencies) 단원을 참조하십시오.
## 5단계: 코드 실행
이 단계에서는 AWS Cloud9 IDE를 사용하여 실행 중인 Docker 컨테이너 내에서 샘플 애플리케이션을 실행합니다.
1. 실행 중인 컨테이너에 대해 AWS Cloud9 IDE가 표시된 상태에서 샘플 채팅 서버를 시작합니다. 이렇게 하려면 **Environment(환경)** 창에서 샘플 `workspace/server.js` 파일을 마우스 오른쪽 버튼으로 클릭하고 나서 **Run(실행)**을 선택합니다.
1. 샘플 애플리케이션을 미리 봅니다. 이렇게 하려면 **Environment(환경)** 창에서 `workspace/client/index.html` 파일을 엽니다. 그런 다음, 메뉴 모음에서 **Tools, Preview, Preview Running Application(도구, 미리 보기, 실행 중인 애플리케이션 미리 보기)**을 선택합니다.
1. 애플리케이션의 미리 보기 탭에서 **Your Name(이름)**에 자신의 이름을 입력합니다. [**Message**]에 메시지를 입력합니다. 그런 다음 **Send(전송)**를 선택합니다. 채팅 서버에서 이름과 메시지를 목록에 추가합니다.
## 6단계: 정리
이 단계에서는 환경을 삭제하고 Amazon EC2 인스턴스에서 AWS Cloud9 및 Docker 지원 파일을 제거합니다. 또한이 샘플 사용을 완료한 후 AWS 계정에 지속적인 요금이 부과되지 않도록 하려면 Docker를 실행하는 Amazon EC2 인스턴스를 종료해야 합니다.
### 6.1단계: 환경 삭제
환경을 삭제하려면 [에서 환경 삭제 AWS Cloud9](delete-environment.md) 섹션을 참조하세요.
### 6.2단계: 컨테이너에서 AWS Cloud9 지원 파일 제거
환경을 삭제한 후에도 일부 AWS Cloud9 지원 파일은 여전히 컨테이너에 남아 있습니다. 컨테이너를 계속 사용하고 싶지만 이러한 지원 파일이 더 이상 필요하지 않은 경우 로그인 후 시작 AWS Cloud9 하도록 지정한 컨테이너의 디렉터리에서 `.c9` 폴더를 삭제합니다. 예를 들어 디렉터리가 `~`인 경우 다음과 같이 ** `-r` ** 옵션을 사용하여 ** `rm` ** 명령을 실행합니다.
```
sudo rm -r ~/.c9
```
### 6.3단계: 인스턴스에서 Docker 지원 파일 제거
Amazon EC2 인스턴스에서 Docker 컨테이너, Docker 이미지 및 Docker를 더 이상 유지하지 않고 인스턴스만 유지하려는 경우 다음과 같이 이러한 Docker 지원 파일을 제거할 수 있습니다.
1. 인스턴스에서 도커 컨테이너를 제거합니다. 이렇게 하려면 ** `stop` ** 및 ** `rm` ** 중지 작업과 사용자가 알아볼 수 있는 컨테이너 이름을 사용하여 인스턴스에 대해 ** `docker` ** 명령을 실행합니다.
```
sudo docker stop cloud9
sudo docker rm cloud9
```
1. 인스턴스에서 도커 이미지를 제거합니다. 이렇게 하려면** `image rm` **작업과 이미지의 태그를 사용하여 인스턴스에 대해** `docker` **명령을 실행합니다.
```
sudo docker image rm cloud9-image:latest
```
1. 여전히 존재할 수 있는 추가 도커 지원 파일을 제거합니다. 이렇게 하려면** `system prune` **작업을 사용하여 인스턴스에 대해** `docker` **명령을 실행합니다.
```
sudo docker system prune -a
```
1. 도커를 제거합니다. 이렇게 하려면 제거할 ** `docker` ** 패키지를 지정하고 ** `remove` ** 작업을 사용하여 인스턴스에 대해 ** `yum` ** 명령을 실행합니다.
Amazon Linux의 경우:
```
sudo yum -y remove docker
```
Ubuntu Server:
```
sudo apt -y remove docker
```
또한 이전에 생성한 `Dockerfile` 및 `authorized_keys` 파일도 제거할 수 있습니다. 예를 들면 인스턴스에서 **`rm`** 명령을 실행합니다.
```
sudo rm /tmp/Dockerfile
sudo rm /tmp/authorized_keys
```
### 6.4단계: 인스턴스 종료
Amazon EC2 인스턴스를 종료하려면 *Amazon EC2 사용 설명서*에서 [인스턴스 종료](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html)를 참조하세요.
## 관련 자습서
+ [AWS RoboMaker 개발자 안내서의RoboMaker](https://docs.aws.amazon.com/robomaker/latest/dg/getting-started.html) *AWS RoboMaker *시작하기. 이 자습서에서는 AWS Cloud9 를 사용하여 샘플 로봇 애플리케이션을 수정, 빌드 및 번들링합니다.