

 AWS Cloud9 tidak lagi tersedia untuk pelanggan baru. Pelanggan yang sudah ada AWS Cloud9 dapat terus menggunakan layanan seperti biasa. [Pelajari selengkapnya](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Tutorial Docker untuk AWS Cloud9
<a name="sample-docker"></a>

Tutorial ini menunjukkan cara menghubungkan lingkungan pengembangan AWS Cloud9 SSH ke container Docker yang sedang berjalan di dalam instance Amazon Linux di Amazon EC2. Ini memungkinkan Anda untuk menggunakan AWS Cloud9 IDE untuk bekerja dengan kode dan file di dalam wadah Docker dan untuk menjalankan perintah pada wadah itu. Untuk informasi tentang Docker, lihat [Apa itu Docker](https://www.docker.com/what-docker) di situs web Docker.

Mengikuti tutorial ini dan membuat sampel ini dapat mengakibatkan biaya ke AWS akun Anda. Ini termasuk kemungkinan biaya untuk layanan seperti Amazon EC2. Untuk informasi selengkapnya, lihat [Penetapan Harga Amazon EC2](https://aws.amazon.com/ec2/pricing/).

**Topics**
+ [Prasyarat](#sample-docker-prereqs)
+ [Langkah 1: Pasang dan jalankan Docker](#sample-docker-install)
+ [Langkah 2: Bangun citra](#sample-docker-build)
+ [Langkah 3: Jalankan kontainer](#sample-docker-run)
+ [Langkah 4: Buat lingkungan](#sample-docker-env)
+ [Langkah 5: Jalankan kode](#sample-docker-code)
+ [Langkah 6: Membersihkan](#sample-docker-clean-up)

## Prasyarat
<a name="sample-docker-prereqs"></a>
+  **Anda harus memiliki instans Amazon EC2 yang menjalankan Amazon Linux atau Ubuntu Server.** Contoh ini mengasumsikan Anda sudah memiliki instans Amazon EC2 yang menjalankan Amazon Linux atau Ubuntu Server di AWS akun Anda. Untuk meluncurkan instans Amazon EC2, lihat [Luncurkan Mesin Virtual Linux](https://aws.amazon.com/getting-started/tutorials/launch-a-virtual-machine/). Di halaman **Pilih Amazon Machine Image (AMI)** dari wizard, pilih AMI yang nama tampilannya dimulai dengan **Amazon Linux AMI** atau **Ubuntu Server**.
+  **Jika instans Amazon EC2 berjalan dalam VPC Amazon, ada persyaratan tambahan.** Lihat [Pengaturan VPC untuk Lingkungan Pengembangan AWS Cloud9](vpc-settings.md).
+  **Instans Amazon EC2 harus memiliki setidaknya 8 hingga 16 GB ruang disk kosong yang tersedia.** Sampel ini menggunakan citra Docker yang berukuran lebih dari 3 GB dan dapat menggunakan penambahan ruang disk sebesar 3 GB atau lebih untuk membangun citra. Jika Anda mencoba menjalankan sampel ini pada disk yang memiliki ruang kosong 8 GB atau kurang, kami menemukan bahwa citra Docker mungkin tidak dibangun atau kontainer Docker mungkin tidak berjalan. Untuk memeriksa ruang disk kosong instans, Anda dapat menjalankan perintah seperti ** `df -h` ** (untuk "informasi sistem file disk dalam format yang dapat dibaca manusia") pada instans. Untuk meningkatkan ukuran disk instans yang ada, lihat [Memodifikasi Volume](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-modify-volume.html) di Panduan *Pengguna Amazon EC2*.

## Langkah 1: Pasang dan jalankan Docker
<a name="sample-docker-install"></a>

Pada langkah ini, Anda memeriksa apakah Docker terpasang pada instans Amazon EC2, dan memasang Docker jika belum terpasang. Setelah Anda memasang Docker, Anda menjalankannya pada instans.

1. Hubungkan ke instans Amazon EC2 yang sedang berjalan dengan menggunakan klien SSH seperti utilitas ** `ssh` ** atau PuTTY. Untuk melakukannya, lihat "Langkah 3: Hubungkan ke Instans Anda" di [Meluncurkan Mesin Virtual Linux](https://aws.amazon.com/getting-started/tutorials/launch-a-virtual-machine/).

1. Periksa apakah Docker terpasang pada instans. Untuk melakukan ini, jalankan perintah ** `docker` ** pada instans dengan opsi ** `--version` **.

   ```
   docker --version
   ```

   Jika Docker terpasang, versi dan nomor build Docker akan ditampilkan. Dalam hal ini, lewati ke langkah 5 nanti dalam prosedur ini.

1. Pasang Docker. Untuk melakukannya, jalankan perintah ** `yum` ** atau ** `apt` ** dengan tindakan ** `install` **, menentukan paket ** `docker` ** atau ** `docker.io` ** yang akan dipasang.

   Untuk Amazon Linux:

   ```
   sudo yum install -y docker
   ```

   Untuk Ubuntu Server:

   ```
   sudo apt install -y docker.io
   ```

1. Konfirmasikan bahwa Docker terpasang. Untuk melakukan ini, jalankan perintah ** `docker --version` ** lagi. Versi dan nomor build Docker ditampilkan.

1. Jalankan Docker. Untuk melakukan ini, jalankan perintah ** `service` ** dengan layanan ** `docker` ** dan tindakan ** `start` **.

   ```
   sudo service docker start
   ```

1. Konfirmasi Docker sedang berjalan. Untuk melakukan ini, jalankan perintah ** `docker` ** dengan tindakan ** `info` **.

   ```
   sudo docker info
   ```

   Jika Docker sedang berjalan, informasi tentang Docker akan ditampilkan.

## Langkah 2: Bangun citra
<a name="sample-docker-build"></a>

Pada langkah ini, Anda menggunakan Dockerfile untuk membangun citra Docker ke dalam instans. Sampel ini menggunakan citra yang menyertakan Node.js dan sampel aplikasi server obrolan.

1. Pada instans, buat Dockerfile. Untuk melakukan ini, dengan klien SSH masih terhubung ke instans, di direktori `/tmp` pada instans, buat file dengan nama `Dockerfile`. Sebagai contoh, jalankan perintah ** `touch` ** seperti berikut.

   ```
   sudo touch /tmp/Dockerfile
   ```

1. Tambahkan konten berikut ini ke file `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
   ```

   Untuk menambahkan konten sebelumnya ke file `Dockerfile`, Anda dapat menggunakan utilitas ** `vi` ** pada instans sebagai berikut.

   1. Gunakan AWS Cloud9 untuk membuka dan mengedit `/tmp/Dockerfile` file.

      ```
      sudo vi /tmp/Dockerfile
      ```

   1. Tempel konten sebelumnya ke dalam file `Dockerfile`. Jika Anda tidak yakin bagaimana melakukannya, lihat dokumentasi klien SSH Anda.

   1. Beralih ke mode perintah. Untuk melakukan ini, tekan tombol `Esc`. (`-- INSERT --` menghilang dari bagian bawah jendela.)

   1. Ketik `:wq` (untuk menulis ke file `/tmp/Dockerfile`, simpan file, lalu keluar dari ** `vi` **), lalu tekan `Enter`.
**catatan**  
Anda dapat mengakses daftar gambar Docker yang sering diperbarui dari AWS CodeBuild. Untuk informasi selengkapnya, lihat [gambar Docker yang disediakan oleh CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-available.html) di *Panduan AWS CodeBuild Pengguna*.

1. Pada contoh, buat file yang berisi kunci publik AWS Cloud9 SSH untuk wadah Docker untuk digunakan. Untuk melakukan ini, di direktori yang sama dengan file `Dockerfile`, buat file dengan nama `authorized_keys`, misalnya, dengan menjalankan perintah ** `touch` **.

   ```
   sudo touch /tmp/authorized_keys
   ```

1. Tambahkan kunci publik AWS Cloud9 SSH ke `authorized_keys` file. Untuk mendapatkan kunci publik AWS Cloud9 SSH, lakukan hal berikut:

   1. Buka AWS Cloud9 konsol di [https://console.aws.amazon.com/cloud9/](https://console.aws.amazon.com/cloud9/).

   1. Di bilah AWS navigasi, di pemilih AWS Wilayah, pilih AWS Wilayah tempat Anda ingin membuat lingkungan AWS Cloud9 pengembangan nanti dalam topik ini.

   1. Jika halaman selamat datang ditampilkan, untuk ** AWS Cloud9 Lingkungan baru**, pilih **Buat lingkungan**. Jika tidak, pilih **Buat lingkungan**.

   1. Pada halaman **Nama lingkungan**, untuk **Nama**, ketikkan nama untuk lingkungan. (Nama tidak penting di sini. Anda akan memilih nama lain nanti.)

   1. Pilih **Langkah selanjutnya**.

   1. Untuk **Tipe Lingkungan**, pilih **Hubungkan dan jalankan di server jarak jauh (SSH)**.

   1. Luaskan **Lihat kunci SSH publik**.

   1. Pilih **Tempel kunci ke clipboard**. (Ini antara **Lihat kunci SSH publik** dan **Pengaturan lanjutan**.)

   1. Pilih **Batalkan**.

   1. Tempelkan konten clipboard ke dalam file `authorized_keys`, lalu simpan file tersebut. Misalnya, Anda dapat menggunakan utilitas ** `vi` **, seperti yang dijelaskan sebelumnya dalam langkah ini.

1. Bangun citra dengan menjalankan perintah ** `docker` ** dengan tindakan ** `build` **, tambahkan tanda `cloud9-image:latest` ke citra dan tentukan jalur ke file `Dockerfile` yang akan digunakan.

   ```
   sudo docker build -t cloud9-image:latest /tmp
   ```

   Jika berhasil, dua baris terakhir dari output bangunan menampilkan `Successfully built` dan `Successfully tagged`.

   Untuk mengonfirmasi bahwa Docker berhasil membuat citra, jalankan perintah ** `docker` ** dengan tindakan `image ls`.

   ```
   sudo docker image ls
   ```

   Jika berhasil, output menampilkan entri di mana bidang `REPOSITORY` diatur ke `cloud9-image` dan bidang `TAG` diatur ke `latest`.

1. Membuat catatan alamat IP publik instans Amazon EC2. Anda akan membutuhkannya untuk [Langkah 4: Buat lingkungan](#sample-docker-env). Jika Anda tidak yakin apa alamat IP publik dari instans, Anda dapat menjalankan perintah berikut pada instans untuk mendapatkannya.

   ```
   curl http://169.254.169.254/latest/meta-data/public-ipv4
   ```

## Langkah 3: Jalankan kontainer
<a name="sample-docker-run"></a>

Pada langkah ini, Anda menjalankan kontainer Docker pada instans. Kontainer ini didasarkan pada citra yang Anda bangun pada langkah sebelumnya.

1. Untuk menjalankan kontainer Docker, jalankan perintah ** `docker` ** pada instans dengan tindakan ** `run` ** dan opsi berikut.

   ```
   sudo docker run -d -it --expose 9090 -p 0.0.0.0:9090:22 --name cloud9 cloud9-image:latest
   ```
   +  `-d` menjalankan kontainer dalam mode terlepas, keluar setiap kali proses root yang digunakan untuk menjalankan kontainer (dalam sampel ini, klien SSH) keluar.
   +  `-it` menjalankan kontainer dengan pseudo-TTY yang dialokasikan dan membuat STDIN tetap terbuka, meskipun kontainer tidak terlampir.
   +  `--expose` membuat port yang ditentukan (dalam sampel ini, port `9090`) tersedia dari kontainer.
   +  `-p` membuat port yang ditentukan tersedia secara internal untuk instans Amazon EC2 melalui alamat IP dan port yang ditentukan. Dalam sampel ini, port `9090` pada kontainer dapat diakses secara internal melalui port `22` pada instans Amazon EC2.
   +  `--name` adalah nama kontainer yang dapat dibaca manusia (dalam sampel ini, `cloud9`).
   +  `cloud9-image:latest` adalah nama yang dapat dibaca manusia dari citra yang dibuat untuk digunakan untuk menjalankan kontainer.

   Untuk mengonfirmasi bahwa Docker berhasil menjalankan kontainer jalankan perintah ** `docker` ** dengan tindakan `container ls`.

   ```
   sudo docker container ls
   ```

   Jika berhasil, output menampilkan entri di mana bidang `IMAGE` diatur ke `cloud9-image:latest` dan bidang `NAMES` diatur ke `cloud9`.

1. Masuk ke kontainer yang sedang berjalan. Untuk melakukannya, jalankan perintah ** `docker` ** dengan tindakan ** `exec` ** dan opsi berikut.

   ```
   sudo docker exec -it cloud9 bash
   ```
   +  `-it` menjalankan kontainer dengan pseudo-TTY yang dialokasikan dan membuat STDIN tetap terbuka, meskipun kontainer tidak terlampir.
   +  `cloud9` adalah nama kontainer yang sedang berjalan yang dapat dibaca manusia.
   +  `bash` memulai shell standar di kontainer yang sedang berjalan.

   Jika berhasil, permintaan terminal berubah untuk menampilkan nama pengguna yang masuk untuk kontainer dan ID kontainer.
**catatan**  
Jika Anda ingin keluar dari kontainer yang sedang berjalan, jalankan perintah ** `exit` **. Prompt terminal berubah kembali untuk menampilkan nama pengguna yang masuk untuk instans dan DNS privat instans. Kontainer tetap harus berjalan.

1. Untuk direktori pada wadah yang sedang berjalan yang AWS Cloud9 ingin Anda mulai setelah masuk, atur izin aksesnya ke **`rwxr-xr-x`**. Ini berarti read-write-execute izin untuk pemilik, izin baca-eksekusi untuk grup, dan izin baca-eksekusi untuk orang lain. Misalnya, jika jalur direktori adalah `~`, Anda dapat mengatur izin ini pada direktori dengan menjalankan perintah ** `chmod` ** di kontainer yang sedang berjalan sebagai berikut.

   ```
   sudo chmod u=rwx,g=rx,o=rx ~
   ```

1. Catat jalur ke direktori pada kontainer berjalan yang berisi biner Node.js, karena Anda akan membutuhkannya untuk [Langkah 4: Buat lingkungan](#sample-docker-env). Jika Anda tidak yakin jalur apa ini, jalankan perintah berikut pada kontainer yang sedang berjalan untuk mendapatkannya.

   ```
   which node
   ```

## Langkah 4: Buat lingkungan
<a name="sample-docker-env"></a>

Pada langkah ini, Anda gunakan AWS Cloud9 untuk membuat lingkungan pengembangan AWS Cloud9 SSH dan menghubungkannya ke wadah Docker yang sedang berjalan. Setelah AWS Cloud9 menciptakan lingkungan, ini menampilkan AWS Cloud9 IDE sehingga Anda dapat mulai bekerja dengan file dan kode dalam wadah.

Anda membuat lingkungan pengembangan AWS Cloud9 SSH dengan AWS Cloud9 konsol. Anda tidak dapat membuat lingkungan SSH menggunakan CLI.

### Prasyarat
<a name="prerequisites"></a>
+ Pastikan Anda menyelesaikan langkah-langkahnya terlebih [Menyiapkan AWS Cloud9](setting-up.md) dahulu. Dengan begitu, Anda dapat masuk ke AWS Cloud9 konsol dan membuat lingkungan.
+ Identifikasi instans komputasi cloud yang ada (misalnya, instans Amazon EC2 di server Akun AWS Anda) atau server Anda sendiri yang AWS Cloud9 ingin Anda sambungkan ke lingkungan.
+ Pastikan instans yang ada atau server Anda sendiri memenuhi semua [Persyaratan hosting SSH](ssh-settings.md#ssh-settings-requirements). Ini termasuk memiliki versi tertentu dari Python, Node.js dan komponen lain yang sudah diinstal, mengatur izin khusus pada direktori yang Anda inginkan untuk memulai AWS Cloud9 setelah login, dan menyiapkan Amazon Virtual Private Cloud terkait.

### Membuat Lingkungan SSH
<a name="create-the-envsshtitle"></a>

1. Pastikan Anda menyelesaikan prasyarat sebelumnya.

1. Hubungkan ke instans yang ada atau server Anda sendiri dengan menggunakan klien SSH, jika Anda belum terhubung dengannya. Ini memastikan bahwa Anda dapat menambahkan nilai kunci SSH publik yang diperlukan ke instance atau server. Ini dijelaskan kemudian dalam prosedur ini.
**catatan**  
Untuk menyambung ke instans AWS Cloud komputasi yang ada, lihat satu atau beberapa sumber daya berikut:  
Untuk Amazon EC2, lihat [Menyambung ke Instans Linux Anda](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instance.html) di Panduan Pengguna *Amazon EC2*.
Untuk Amazon Lightsail, lihat [Menghubungkan ke instans Lightsail berbasis Linux/Unix Anda](https://lightsail.aws.amazon.com/ls/docs/how-to/article/lightsail-how-to-connect-to-your-instance-virtual-private-server) di *Dokumentasi Amazon Lightsail*.
Untuk AWS Elastic Beanstalk, lihat [Daftar dan Menghubungkan ke Instans Server](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/using-features.ec2connect.html) di *Panduan AWS Elastic Beanstalk Pengembang*.
Untuk AWS OpsWorks, lihat [Menggunakan SSH untuk Masuk ke Instance Linux](https://docs.aws.amazon.com/opsworks/latest/userguide/workinginstances-ssh.html) di *Panduan AWS OpsWorks Pengguna*.
Untuk yang lain Layanan AWS, lihat dokumentasi untuk layanan khusus itu.
Untuk terhubung ke server Anda sendiri, gunakan SSH. SSH sudah diinstal pada sistem operasi macOS dan Linux. Untuk terhubung ke server Anda dengan menggunakan SSH pada Windows, Anda harus menginstal [PuTTY](https://www.putty.org/).

1. Masuk ke AWS Cloud9 konsol, di [https://console.aws.amazon.com/cloud9/](https://console.aws.amazon.com/cloud9/).

1. Setelah Anda masuk ke AWS Cloud9 konsol, di bilah navigasi atas pilih Wilayah AWS untuk membuat lingkungan. Untuk daftar yang tersedia Wilayah AWS, lihat [AWS Cloud9](https://docs.aws.amazon.com/general/latest/gr/rande.html#cloud9_region)di *Referensi Umum AWS*.  
![\[Pemilih wilayah di konsol AWS Cloud9\]](http://docs.aws.amazon.com/id_id/cloud9/latest/user-guide/images/consolas_region_new_UX.png)

1. Jika ini adalah pertama kalinya Anda membuat lingkungan pengembangan, halaman selamat datang akan ditampilkan. Di panel ** AWS Cloud9 lingkungan baru**, pilih **Buat lingkungan**.

   Jika sebelumnya Anda telah membuat lingkungan pengembangan, Anda juga dapat memperluas panel di sebelah kiri layar. Pilih **lingkungan Anda**, lalu pilih **Buat lingkungan**.

   Di halaman **selamat datang**:  
![\[Pilih tombol Buat lingkungan jika halaman selamat datang ditampilkan\]](http://docs.aws.amazon.com/id_id/cloud9/latest/user-guide/images/create_welcome_env_new_UX.png)

   Atau di halaman **Lingkungan Anda**:  
![\[Pilih tombol Buat lingkungan jika halaman selamat datang tidak ditampilkan\]](http://docs.aws.amazon.com/id_id/cloud9/latest/user-guide/images/console_create_env_new_UX.png)

1. Pada halaman **Buat lingkungan**, masukkan nama untuk lingkungan Anda.

1. Untuk **Deskripsi**, memasukkan sesuatu tentang lingkungan Anda. Untuk tutorial ini, gunakan `This environment is for the AWS Cloud9 tutorial.`

1. Untuk **jenis Lingkungan**, pilih **Komputasi yang Ada** dari opsi berikut:
   + Instans **EC2 baru — Meluncurkan instans** Amazon EC2 AWS Cloud9 yang dapat terhubung langsung melalui SSH.
   + **Komputasi yang ada** — Meluncurkan instans Amazon EC2 yang tidak memerlukan port masuk terbuka. AWS Cloud9 terhubung ke instance melalui [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager.html).
     + Jika Anda memilih opsi **Komputasi yang ada**, peran layanan dan profil instans IAM akan dibuat untuk memungkinkan Systems Manager berinteraksi dengan instans EC2 atas nama Anda. Anda dapat melihat nama-nama keduanya di bagian **Peran layanan dan profil instans untuk akses Systems Manager** lebih jauh ke bawah antarmuka. Untuk informasi selengkapnya, lihat [Mengakses instans EC2 no-ingress dengan AWS Systems Manager](ec2-ssm.md). 
**Awas**  
Membuat instans EC2 untuk lingkungan Anda dapat mengakibatkan kemungkinan biaya Akun AWS untuk Amazon EC2 Anda. Tidak ada biaya tambahan untuk menggunakan Systems Manager untuk mengelola koneksi ke instans EC2 Anda.
**Awas**  
AWS Cloud9 menggunakan kunci publik SSH untuk terhubung dengan aman ke server Anda. Untuk membuat koneksi aman, tambahkan kunci publik kami ke `~/.ssh/authorized_keys` file Anda dan berikan kredensi login Anda dalam langkah-langkah berikut. Pilih **Salin kunci ke clipboard** untuk menyalin kunci SSH, atau **Lihat kunci SSH publik untuk menampilkannya**.

1. Pada panel **komputasi yang ada**, untuk **Pengguna**, masukkan nama login yang Anda gunakan untuk terhubung ke instance atau server sebelumnya dalam prosedur ini. Misalnya, untuk contoh AWS Cloud komputasi, mungkin`ec2-user`,`ubuntu`, atau`root`. 
**catatan**  
Kami menyarankan agar nama login dikaitkan dengan izin administratif atau pengguna administrator pada instance atau server. Lebih khusus lagi, kami menyarankan agar nama login ini memiliki instalasi Node.js pada instance atau server. Untuk memeriksa ini, dari terminal instance atau server Anda, jalankan perintah **`ls -l $(which node)`**(atau **`ls -l $(nvm which node)`**jika Anda menggunakan`nvm`). Perintah ini menampilkan nama pemilik instalasi Node.js. Ini juga menampilkan izin instalasi, nama grup, dan lokasi.

1. Untuk **Host**, masukkan alamat IP publik (lebih disukai) atau nama host dari instance atau server.

1. Untuk **Port**, masukkan port yang AWS Cloud9 ingin Anda gunakan untuk mencoba terhubung ke instance atau server. Atau, pertahankan port default.

1. Pilih **Detail tambahan - opsional** untuk menampilkan jalur lingkungan, jalur ke biner node.js dan informasi host lompat SSH.

1. Untuk **jalur Lingkungan**, masukkan jalur ke direktori pada instance atau server yang AWS Cloud9 ingin Anda mulai. Anda mengidentifikasi ini sebelumnya di prasyarat untuk prosedur ini. Jika Anda membiarkannya kosong, AWS Cloud9 menggunakan direktori tempat instans atau server Anda biasanya memulai setelah login. Ini biasanya merupakan direktori beranda atau default.

1. **Untuk jalur biner Path to Node.js**, masukkan informasi jalur untuk menentukan jalur ke biner Node.js pada instance atau server. Untuk mendapatkan jalur, Anda dapat menjalankan perintah **`which node`**(atau **`nvm which node`**jika Anda menggunakan`nvm`) pada instance atau server Anda. Misalnya, jalurnya mungkin `/usr/bin/node`. Jika Anda membiarkannya kosong, AWS Cloud9 mencoba menebak di mana biner Node.js saat mencoba terhubung.

1. Untuk **host lompat SSH**, masukkan informasi tentang host lompat yang digunakan instance atau server. Gunakan format `USER_NAME@HOSTNAME:PORT_NUMBER` (misalnya,`ec2-user@:ip-192-0-2-0:22`).

   Host lompat harus memenuhi persyaratan berikut:
   + Jump host harus dapat dijangkau melalui internet publik menggunakan SSH.
   + Jump host harus memungkinkan akses masuk oleh alamat IP apa pun melalui port tertentu.
   + Nilai kunci SSH publik yang disalin ke file `~/.ssh/authorized_keys` pada instans atau server yang ada juga harus disalin ke file `~/.ssh/authorized_keys` pada jump host.
   + Netcat harus diinstal.

1. Menambahkan hingga 50 tanda dengan menyediakan **Kunci** dan sebuah **Nilai** untuk setiap tanda. Lakukan dengan memilih **Tambahkan tag baru**. Tag dilampirkan ke AWS Cloud9 lingkungan sebagai tag sumber daya, dan disebarkan ke sumber daya dasar berikut: CloudFormation tumpukan, instans Amazon EC2, dan grup keamanan Amazon EC2. Untuk mempelajari lebih lanjut tentang tag, lihat [Mengontrol Akses Menggunakan Tag AWS Sumber Daya](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html) di *[Panduan Pengguna IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/)* dan [informasi lanjutan](tags.md) tentang tag dalam panduan ini.
**Awas**  
Jika Anda memperbarui tag ini setelah Anda membuatnya, perubahan tidak disebarkan ke sumber daya yang mendasarinya. Untuk informasi selengkapnya, lihat [Menyebarkan pembaruan tanda ke sumber daya yang mendasari](tags.md#tags-propagate) dalam informasi lanjutan tentang [tanda](tags.md).

1. Pilih **Buat** untuk membuat lingkungan Anda, dan Anda kemudian diarahkan ke halaman beranda. Ketika akun berhasil dibuat, bilah flash hijau muncul di bagian atas AWS Cloud9 konsol. Anda dapat memilih lingkungan baru dan memilih **Buka di Cloud9** untuk meluncurkan IDE.   
![\[AWS Cloud9 Pemilih IDE di konsol AWS Cloud9\]](http://docs.aws.amazon.com/id_id/cloud9/latest/user-guide/images/cloud9-ide-open.png)

   Jika akun gagal dibuat, bilah flash merah muncul di bagian atas AWS Cloud9 konsol. Akun Anda mungkin gagal dibuat karena masalah dengan browser web Anda, izin AWS akses Anda, instans, atau jaringan terkait. Anda dapat menemukan informasi tentang kemungkinan perbaikan pada masalah yang mungkin menyebabkan akun gagal di bagian [AWS Cloud9 Pemecahan Masalah](troubleshooting.md#troubleshooting-env-loading).

**catatan**  
Jika lingkungan Anda menggunakan proxy untuk mengakses internet, Anda harus memberikan detail proxy AWS Cloud9 agar dapat menginstal dependensi. Untuk informasi selengkapnya, lihat [Gagal menginstal dependensi](troubleshooting.md#proxy-failed-dependencies).

## Langkah 5: Jalankan kode
<a name="sample-docker-code"></a>

Pada langkah ini, Anda menggunakan AWS Cloud9 IDE untuk menjalankan aplikasi sampel di dalam wadah Docker yang sedang berjalan.

1. Dengan AWS Cloud9 IDE ditampilkan untuk wadah yang sedang berjalan, mulai server obrolan sampel. Untuk melakukannya, di jendela **Lingkungan**, klik kanan file sampel `workspace/server.js`, lalu pilih **Jalankan**.

1. Pratinjau aplikasi sampel. Untuk melakukan ini, di jendela **Lingkungan**, buka file `workspace/client/index.html`. Kemudian, pada bilah menu, pilih **Alat, Pratinjau, Pratinjau Aplikasi yang Berjalan**.

1. Pada tab pratinjau aplikasi, untuk **Nama Anda**, ketikkan nama Anda. Untuk **Pesan**, ketik pesan. Lalu, pilih **Kirim**. Server obrolan menambahkan nama dan pesan Anda ke daftar.

## Langkah 6: Membersihkan
<a name="sample-docker-clean-up"></a>

Pada langkah ini, Anda menghapus lingkungan AWS Cloud9 dan menghapus serta file dukungan Docker dari instans Amazon EC2. Selain itu, untuk mencegah tagihan berkelanjutan ke AWS akun Anda setelah selesai menggunakan sampel ini, Anda harus menghentikan instans Amazon EC2 yang menjalankan Docker.

### Langkah 6.1: Hapus lingkungan
<a name="step-6-1-delete-the-envtitle"></a>

Untuk menghapus lingkungan, lihat [Menghapus lingkungan di AWS Cloud9](delete-environment.md).

### Langkah 6.2: Hapus file AWS Cloud9 dukungan dari wadah
<a name="step-6-2-remove-ac9-support-files-from-the-container"></a>

Setelah Anda menghapus lingkungan, beberapa file AWS Cloud9 dukungan masih tetap berada di wadah. Jika Anda ingin tetap menggunakan wadah tetapi tidak lagi membutuhkan file dukungan ini, hapus `.c9` folder dari direktori pada wadah yang Anda tentukan AWS Cloud9 untuk memulai setelah masuk. Misalnya, jika direktorinya adalah `~`, jalankan perintah ** `rm` ** dengan opsi ** `-r` ** sebagai berikut.

```
sudo rm -r ~/.c9
```

### Langkah 6.3: Hapus file dukungan Docker dari instans
<a name="step-6-3-remove-docker-support-files-from-the-instance"></a>

Jika Anda tidak ingin lagi menyimpan kontainer Docker, citra Docker, dan Docker pada instans Amazon EC2, tetapi Anda ingin menyimpan instans, Anda dapat menghapus file dukungan Docker ini sebagai berikut.

1. Hapus kontainer Docker dari instans. Untuk melakukannya, jalankan perintah ** `docker` ** pada instans dengan tindakan penghentian ** `stop` ** dan ** `rm` ** dan nama kontainer yang dapat dibaca manusia.

   ```
   sudo docker stop cloud9
   sudo docker rm cloud9
   ```

1. Hapus citra Docker dari instans. Untuk melakukannya, jalankan perintah ** `docker` ** pada instans dengan tindakan ** `image rm` ** dan tanda citra.

   ```
   sudo docker image rm cloud9-image:latest
   ```

1. Hapus file dukungan Docker tambahan yang mungkin masih keluar. Untuk melakukan ini, jalankan perintah ** `docker` ** pada instans dengan tindakan ** `system prune` **.

   ```
   sudo docker system prune -a
   ```

1. Copot pemasangan Docker. Untuk melakukannya, jalankan perintah ** `yum` ** pada instans dengan tindakan ** `remove` **, menentukan paket ** `docker` ** yang akan dihapus pemasangannya.

   Untuk Amazon Linux:

   ```
   sudo yum -y remove docker
   ```

   Untuk Ubuntu Server:

   ```
   sudo apt -y remove docker
   ```

   Anda juga dapat menghapus file `Dockerfile` dan `authorized_keys` yang Anda buat sebelumnya. Sebagai contoh, jalankan perintah ** `rm` ** pada instans.

   ```
   sudo rm /tmp/Dockerfile
   sudo rm /tmp/authorized_keys
   ```

### Langkah 6.4: Akhiri instans
<a name="step-6-4-terminate-the-instance"></a>

Untuk menghentikan instans Amazon EC2, [lihat Menghentikan Instans Anda di Panduan](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html) Pengguna Amazon *EC2*.