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

# Menyebarkan aplikasi Node.js Express ke Elastic Beanstalk
<a name="create_deploy_nodejs_express"></a>

[Bagian ini memandu Anda melalui penerapan aplikasi sampel ke Elastic Beanstalk menggunakan Elastic Beanstalk Command Line Interface (EB CLI) dan kemudian memperbarui aplikasi untuk menggunakan framework Express.](http://expressjs.com/) 

## Prasyarat
<a name="create_deploy_nodejs_express.prerequisites"></a>

Tutorial ini membutuhkan prasyarat berikut:
+ Runtime Node.js
+ Perangkat lunak pengelola paket Node.js default, npm
+ Generator baris perintah Express
+ Antarmuka Baris Perintah Elastic Beanstalk (EB CLI)

Untuk detail tentang menginstal tiga komponen pertama yang terdaftar dan menyiapkan lingkungan pengembangan lokal Anda, lihat[Menyiapkan lingkungan pengembangan Node.js Anda untuk Elastic Beanstalk](nodejs-devenv.md). Untuk tutorial ini, Anda tidak perlu menginstal AWS SDK untuk Node.js, yang juga disebutkan dalam topik yang direferensikan.

Untuk detail tentang menginstal dan mengonfigurasi CLI EB, lihat dan. [Instal EB CLI dengan skrip pengaturan (disarankan)](eb-cli3.md#eb-cli3-install) [Mengonfigurasi EB CLI](eb-cli3-configuration.md)

## Membuat lingkungan Elastic Beanstalk
<a name="create_deploy_nodejs_express.eb_init-rds"></a>

**Direktori aplikasi Anda**  
Tutorial ini menggunakan direktori yang disebut `nodejs-example-express-rds` untuk bundel sumber aplikasi. Buat `nodejs-example-express-rds` direktori untuk tutorial ini.

```
~$ mkdir nodejs-example-express-rds
```

**catatan**  
Setiap tutorial dalam chapter ini menggunakan direktorinya sendiri untuk bundel sumber aplikasi. Nama direktori cocok dengan nama aplikasi sampel yang digunakan oleh tutorial.

Ubah direktori kerja Anda saat ini menjadi`nodejs-example-express-rds`.

```
~$ cd nodejs-example-express-rds
```

Sekarang, mari kita mengatur lingkungan Elastic Beanstalk yang menjalankan platform Node.js dan aplikasi sampel. Kita akan menggunakan antarmuka baris perintah Elastic Beanstalk (EB CLI).

**Untuk mengonfigurasi repositori EB CLI untuk aplikasi Anda dan membuat lingkungan Elastic Beanstalk yang menjalankan platform Node.js**

1. Buat repositori dengan perintah **[**eb init**](eb3-init.md)**.

   ```
   ~/nodejs-example-express-rds$ eb init --platform node.js --region <region>
   ```

   Perintah ini membuat file konfigurasi dalam folder bernama `.elasticbeanstalk` yang menentukan pengaturan dalam membuat lingkungan untuk aplikasi Anda, dan membuat sebuah aplikasi Elastic Beanstalk yang diambil dari nama folder saat ini.

1. Buat lingkungan yang menjalankan aplikasi sampel dengan perintah **[**eb create**](eb3-create.md)**.

   ```
   ~/nodejs-example-express-rds$ eb create --sample nodejs-example-express-rds
   ```

   Perintah ini membuat lingkungan yang seimbang beban dengan pengaturan default untuk platform Node.js dan sumber daya berikut:
   + **EC2 instance** — Mesin virtual Amazon Elastic Compute Cloud (Amazon EC2) yang dikonfigurasi untuk menjalankan aplikasi web pada platform yang Anda pilih.

     Setiap platform menjalankan satu set perangkat lunak, file konfigurasi dan penulisan tertentu untuk mendukung versi bahasa, kerangka kerja, kontainer web tertentu, atau kombinasi dari semua ini. Sebagian besar platform menggunakan Apache atau NGINX sebagai proksi terbalik yang ada di depan aplikasi web Anda, meneruskan permintaan ke aplikasi web, menyajikan aset statis, dan menghasilkan log akses dan kesalahan.
   + **Grup keamanan instans — Grup** EC2 keamanan Amazon yang dikonfigurasi untuk memungkinkan lalu lintas masuk pada port 80. Sumber daya ini memungkinkan lalu lintas HTTP dari penyeimbang beban mencapai EC2 instance yang menjalankan aplikasi web Anda. Secara default, lalu lintas tidak diizinkan di port lain.
   + **Penyeimbang beban** – Penyeimbang beban Elastic Load Balancing yang dikonfigurasi untuk mendistribusikan permintaan ke instans yang menjalankan aplikasi Anda. Penyeimbang beban juga menghilangkan kebutuhan untuk mengekspos instans Anda langsung ke internet.
   + **Grup keamanan penyeimbang beban - Grup** EC2 keamanan Amazon yang dikonfigurasi untuk memungkinkan lalu lintas masuk di port 80. Sumber daya ini memungkinkan lalu lintas HTTP dari internet mencapai penyeimbang beban. Secara default, lalu lintas tidak diizinkan di port lain.
   + **Grup Auto Scaling** – Grup Auto Scaling yang dikonfigurasi untuk menggantikan instans jika diakhiri atau menjadi tidak tersedia.
   + **Bucket Amazon S3** – Lokasi penyimpanan untuk kode sumber, log, dan artifact lainnya yang dibuat saat Anda menggunakan Elastic Beanstalk.
   + ** CloudWatch Alarm Amazon** — Dua CloudWatch alarm yang memantau beban pada instans di lingkungan Anda dan yang dipicu jika beban terlalu tinggi atau terlalu rendah. Saat alarm terpicu, grup Auto Scaling Anda akan menaikkan atau menurunkan skala sebagai respons.
   + **CloudFormation stack** - Elastic CloudFormation Beanstalk digunakan untuk meluncurkan sumber daya di lingkungan Anda dan menyebarkan perubahan konfigurasi. Sumber daya ditentukan di sebuah templat yang dapat Anda lihat di [Konsol CloudFormation](https://console.aws.amazon.com/cloudformation).
   + **Nama domain — Nama** domain yang merutekan ke aplikasi web Anda dalam formulir **subdomain*. *region*.elasticbeanstalk.com*.
**Keamanan domain**  
[Untuk meningkatkan keamanan aplikasi Elastic Beanstalk Anda, domain elasticbeanstalk.com terdaftar di *Daftar* Akhiran Publik (PSL).](https://publicsuffix.org/)  
Jika Anda perlu mengatur cookie sensitif di nama domain default untuk aplikasi Elastic Beanstalk Anda, kami sarankan Anda menggunakan cookie `__Host-` dengan awalan untuk meningkatkan keamanan. Praktik ini melindungi domain Anda dari upaya pemalsuan permintaan lintas situs (CSRF). Untuk informasi selengkapnya, lihat halaman [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes) di Jaringan Pengembang Mozilla.

1. Ketika pembuatan lingkungan selesai, gunakan perintah [**eb open**](eb3-open.md) untuk membuka URL lingkungan di browser default.

   ```
   ~/nodejs-example-express-rds$ eb open
   ```

Anda sekarang telah membuat lingkungan Elastic Beanstalk Node.js dengan aplikasi sampel. Anda dapat memperbaruinya dengan aplikasi Anda sendiri. Selanjutnya, kami memperbarui aplikasi sampel untuk menggunakan kerangka kerja Express.

## Perbarui aplikasi untuk menggunakan Express
<a name="create_deploy_nodejs_express.update"></a>

Setelah Anda membuat lingkungan dengan aplikasi sampel, Anda dapat memperbaruinya dengan aplikasi Anda sendiri. Dalam prosedur ini, pertama-tama kita menjalankan **npm install** perintah **express** dan untuk mengatur kerangka kerja Express di direktori aplikasi Anda. Kemudian kami menggunakan EB CLI untuk memperbarui lingkungan Elastic Beanstalk Anda dengan aplikasi yang diperbarui.

**Memperbarui aplikasi Anda untuk menggunakan Express**

1. Jalankan perintah `express`. Perintah menghasilkan `package.json`, `app.js`, dan beberapa direktori.

   ```
   ~/nodejs-example-express-rds$ express
   ```

   Saat diminta, ketik **y** jika Anda ingin melanjutkan.
**catatan**  
Jika **express** perintah tidak berfungsi, Anda mungkin belum menginstal generator baris perintah Express seperti yang dijelaskan di bagian *Prasyarat* sebelumnya. Atau pengaturan jalur direktori untuk mesin lokal Anda mungkin perlu diatur untuk menjalankan **express** perintah. Lihat bagian *Prasyarat* untuk langkah-langkah rinci tentang pengaturan lingkungan pengembangan Anda, sehingga Anda dapat melanjutkan dengan tutorial ini. 

1. Persiapkan dependensi lokal.

   ```
   ~/nodejs-example-express-rds$ npm install
   ```

1. (Opsional) Verifikasi server aplikasi web dimulai.

   ```
   ~/nodejs-example-express-rds$ npm start
   ```

   Anda akan melihat output yang serupa dengan yang berikut:

   ```
   > nodejs@0.0.0 start /home/local/user/node-express
   > node ./bin/www
   ```

   Server berjalan pada port 3000 secara default. Untuk mengujinya, jalankan `curl http://localhost:3000` di terminal lain, atau buka browser di komputer lokal dan masukkan alamat URL`http://localhost:3000`.

   Tekan **Ctrl\$1C** untuk menghentikan server.

1. Terapkan perubahan ke lingkungan Elastic Beanstalk Anda dengan perintah. [**eb deploy**](eb3-deploy.md)

   ```
   ~/nodejs-example-express-rds$ eb deploy
   ```

1. Setelah lingkungan berwarna hijau dan siap, refresh URL untuk memverifikasi bahwa itu berfungsi. Anda akan melihat halaman web yang bertuliskan **Selamat Datang di Express**.

Selanjutnya, mari kita perbarui aplikasi Express untuk menyajikan file statis dan menambahkan halaman baru.

**Untuk mengonfigurasi file statis dan menambahkan halaman baru ke aplikasi Express**

1. Tambahkan file konfigurasi kedua di [`.ebextensions`](ebextensions.md)folder dengan konten berikut:

   **`nodejs-example-express-rds/.ebextensions/staticfiles.config`**

   ```
   option_settings:
       aws:elasticbeanstalk:environment:proxy:staticfiles:
           /stylesheets: public/stylesheets
   ```

   Pengaturan ini mengonfigurasi server proksi untuk menyajikan file di folder `public` pada jalur `/public` aplikasi. Melayani file secara statis dari server proxy mengurangi beban pada aplikasi Anda. Untuk informasi selengkapnya, lihat [File statis](create_deploy_nodejs.container.md#nodejs-platform-console-staticfiles) sebelumnya di Bab ini.

1. (Opsional) Untuk mengonfirmasi bahwa pemetaan statis dikonfigurasi dengan benar, komentari konfigurasi pemetaan statis di. `nodejs-example-express-rds/app.js` Ini menghapus pemetaan dari aplikasi node.

   ```
   //  app.use(express.static(path.join(__dirname, 'public'))); 
   ```

   Pemetaan file statis dalam `staticfiles.config` file dari langkah sebelumnya harus tetap memuat stylesheet dengan sukses, bahkan setelah Anda mengomentari baris ini. Untuk memverifikasi bahwa pemetaan file statis dimuat melalui konfigurasi file statis proxy, bukan aplikasi ekspres, hapus nilai berikut. `option_settings:` Setelah dihapus dari konfigurasi file statis dan aplikasi node, stylesheet akan gagal dimuat.

   Ingatlah untuk mengatur ulang isi dari kedua `nodejs-example-express-rds/app.js` dan `staticfiles.config` ketika Anda selesai pengujian.

1. Menambahkan `nodejs-example-express-rds/routes/hike.js`. Ketik berikut ini:

   ```
   exports.index = function(req, res) {
    res.render('hike', {title: 'My Hiking Log'});
   };
   
   exports.add_hike = function(req, res) {
   };
   ```

1. Perbarui `nodejs-example-express-rds/app.js` untuk menyertakan tiga baris baru.

   Pertama, tambahkan baris berikut untuk menambahkan `require` pada rute ini:

   ```
   var hike = require('./routes/hike');
   ```

   File Anda akan terlihat mirip dengan snippet berikut:

   ```
   var express = require('express');
   var path = require('path');
   var hike = require('./routes/hike');
   ```

   Kemudian, tambahkan dua baris berikut ke `nodejs-example-express-rds/app.js` setelah `var app = express();`

   ```
   app.get('/hikes', hike.index);
   app.post('/add_hike', hike.add_hike);
   ```

   File Anda akan terlihat mirip dengan snippet berikut:

   ```
   var app = express();
   app.get('/hikes', hike.index);
   app.post('/add_hike', hike.add_hike);
   ```

1. Salin `nodejs-example-express-rds/views/index.jade` ke `nodejs-example-express-rds/views/hike.jade`. 

   ```
   ~/nodejs-example-express-rds$ cp views/index.jade views/hike.jade
   ```

1. Terapkan perubahan dengan [**eb deploy**](eb3-deploy.md)perintah.

   ```
   ~/nodejs-example-express-rds$ eb deploy
   ```

1. Lingkungan Anda akan diperbarui setelah beberapa menit. Setelah lingkungan Anda hijau dan siap, verifikasi bahwa itu bekerja dengan me-refresh peramban Anda dan menambahkan **hikes** di akhir URL (misalnya, `http://node-express-env-syypntcz2q.elasticbeanstalk.com/hikes`).

   Anda akan melihat halaman web berjudul **Log Hiking Saya**.

Anda sekarang telah membuat aplikasi web yang menggunakan kerangka kerja Express. Di bagian berikutnya, kita akan memodifikasi aplikasi untuk menggunakan Amazon Relational Database Service (RDS) untuk menyimpan log hiking.

## Perbarui aplikasi untuk menggunakan Amazon RDS
<a name="create_deploy_nodejs_express.add_rds"></a>

Pada langkah selanjutnya ini kami memperbarui aplikasi untuk menggunakan Amazon RDS for MySQL.

**Untuk memperbarui aplikasi Anda untuk menggunakan RDS untuk MySQL**

1. [Untuk membuat database RDS untuk MySQL yang digabungkan ke lingkungan Elastic Beanstalk Anda, ikuti petunjuk dalam topik Menambahkan database yang disertakan nanti dalam chapter ini.](create-deploy-nodejs.rds.md) Menambahkan instance database membutuhkan waktu sekitar 10 menit.

1.  Perbarui bagian dependensi di `package.json` dengan konten berikut: 

   ```
   "dependencies": {
       "async": "^3.2.4",
       "express": "4.18.2",
       "jade": "1.11.0",
       "mysql": "2.18.1",
       "node-uuid": "^1.4.8",
       "body-parser": "^1.20.1",
       "method-override": "^3.0.0",
       "morgan": "^1.10.0",
       "errorhandler": "^1.5.1"
     }
   ```

1. Jalankan **npm install**.

   ```
   ~/nodejs-example-express-rds$ npm install
   ```

1. Perbarui `app.js` untuk terhubung ke database, membuat tabel, dan menyisipkan log hiking default tunggal. Setiap kali aplikasi ini digunakan, aplikasi ini akan menjatuhkan tabel kenaikan sebelumnya dan membuatnya kembali.

   ```
   /**
    * Module dependencies.
    */
   
    const express = require('express')
    , routes = require('./routes')
    , hike = require('./routes/hike')
    , http = require('http')
    , path = require('path')
    , mysql = require('mysql')
    , async = require('async')
    , bodyParser = require('body-parser')
    , methodOverride = require('method-override')
    , morgan = require('morgan')
    , errorhandler = require('errorhandler');
   
   const { connect } = require('http2');
   
   const app = express()
   
   app.set('views', __dirname + '/views')
   app.set('view engine', 'jade')
   app.use(methodOverride())
   app.use(bodyParser.json())
   app.use(bodyParser.urlencoded({ extended: true }))
   app.use(express.static(path.join(__dirname, 'public')))
   
   
   app.set('connection', mysql.createConnection({
   host: process.env.RDS_HOSTNAME,
   user: process.env.RDS_USERNAME,
   password: process.env.RDS_PASSWORD,
   port: process.env.RDS_PORT}));  
   
   function init() {
    app.get('/', routes.index);
    app.get('/hikes', hike.index);
    app.post('/add_hike', hike.add_hike);
   }
   
   const client = app.get('connection');
   async.series([
    function connect(callback) {
      client.connect(callback);
      console.log('Connected!');
    },
    function clear(callback) {
      client.query('DROP DATABASE IF EXISTS mynode_db', callback);
    },
    function create_db(callback) {
      client.query('CREATE DATABASE mynode_db', callback);
    },
    function use_db(callback) {
      client.query('USE mynode_db', callback);
    },
    function create_table(callback) {
       client.query('CREATE TABLE HIKES (' +
                           'ID VARCHAR(40), ' +
                           'HIKE_DATE DATE, ' +
                           'NAME VARCHAR(40), ' +
                           'DISTANCE VARCHAR(40), ' +
                           'LOCATION VARCHAR(40), ' +
                           'WEATHER VARCHAR(40), ' +
                           'PRIMARY KEY(ID))', callback);
    },
    function insert_default(callback) {
      const hike = {HIKE_DATE: new Date(), NAME: 'Hazard Stevens',
            LOCATION: 'Mt Rainier', DISTANCE: '4,027m vertical', WEATHER:'Bad', ID: '12345'};
      client.query('INSERT INTO HIKES set ?', hike, callback);
    }
   ], function (err, results) {
    if (err) {
      console.log('Exception initializing database.');
      throw err;
    } else {
      console.log('Database initialization complete.');
      init();
    }
   });
   
   module.exports = app
   ```

1. Tambahkan konten berikut ke`routes/hike.js`. Ini akan memungkinkan rute untuk memasukkan log hiking baru ke database *HIKES.*

   ```
   const uuid = require('node-uuid');
   exports.index = function(req, res) {
     res.app.get('connection').query( 'SELECT * FROM HIKES', function(err,
   rows) {
       if (err) {
         res.send(err);
       } else {
         console.log(JSON.stringify(rows));
         res.render('hike', {title: 'My Hiking Log', hikes: rows});
     }});
   };
   exports.add_hike = function(req, res){
     const input = req.body.hike;
     const hike = { HIKE_DATE: new Date(), ID: uuid.v4(), NAME: input.NAME,
     LOCATION: input.LOCATION, DISTANCE: input.DISTANCE, WEATHER: input.WEATHER};
     console.log('Request to log hike:' + JSON.stringify(hike));
     req.app.get('connection').query('INSERT INTO HIKES set ?', hike, function(err) {
         if (err) {
           res.send(err);
         } else {
           res.redirect('/hikes');
         }
      });
   };
   ```

1. Ganti konten `routes/index.js` dengan yang berikut ini:

   ```
   /*
    * GET home page.
    */
   
   exports.index = function(req, res){
     res.render('index', { title: 'Express' });
   };
   ```

1. Tambahkan template giok berikut `views/hike.jade` untuk menyediakan antarmuka pengguna untuk menambahkan log hiking.

   ```
   extends layout
   
   block content
     h1= title
     p Welcome to #{title}
   
     form(action="/add_hike", method="post")
       table(border="1")
         tr
           td Your Name
           td
             input(name="hike[NAME]", type="textbox")
         tr
           td Location
           td
             input(name="hike[LOCATION]", type="textbox")
         tr
           td Distance
           td
             input(name="hike[DISTANCE]", type="textbox")
         tr
           td Weather
           td
             input(name="hike[WEATHER]", type="radio", value="Good")
             | Good
             input(name="hike[WEATHER]", type="radio", value="Bad")
             | Bad
             input(name="hike[WEATHER]", type="radio", value="Seattle", checked)
             | Seattle
         tr
           td(colspan="2")
             input(type="submit", value="Record Hike")
   
     div
       h3 Hikes
       table(border="1")
         tr
           td Date
           td Name
           td Location
           td Distance
           td Weather
         each hike in hikes
           tr
             td #{hike.HIKE_DATE.toDateString()}
             td #{hike.NAME}
             td #{hike.LOCATION}
             td #{hike.DISTANCE}
             td #{hike.WEATHER}
   ```

1. Terapkan perubahan dengan [**eb deploy**](eb3-deploy.md)perintah.

   ```
   ~/nodejs-example-express-rds$ eb deploy
   ```

## Bersihkan
<a name="create_deploy_nodejs_express.delete"></a>

Jika Anda selesai bekerja dengan Elastic Beanstalk, Anda dapat menghentikan lingkungan Anda.

Gunakan perintah **eb terminate** untuk mengakhiri lingkungan Anda dan semua sumber daya yang dimuatnya.

```
~/nodejs-example-express-rds$ eb terminate
The environment "nodejs-example-express-rds-env" and all associated instances will be terminated.
To confirm, type the environment name: nodejs-example-express-rds-env
INFO: terminateEnvironment is starting.
...
```