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

# Men-deploy aplikasi Flask ke Elastic Beanstalk
<a name="create-deploy-python-flask"></a>

Tutorial ini memandu Anda melalui proses menghasilkan aplikasi Flask dan menyebarkannya ke lingkungan AWS Elastic Beanstalk . Flask adalah kerangka kerja aplikasi web sumber terbuka untuk Python. 

Dalam tutorial ini, Anda akan melakukan hal berikut:
+ [Menyiapkan lingkungan virtual Python dengan Flask](#python-flask-setup-venv)
+ [Buat aplikasi Flask](#python-flask-create-app)
+ [Men-deploy situs Anda dengan EB CLI](#python-flask-deploy) 
+ [Pembersihan](#python-flask-tutorial-cleanup) 

## Prasyarat
<a name="python-flask-prereq"></a>

Tutorial ini mengasumsikan Anda memiliki pengetahuan tentang operasi Elastic Beanstalk dasar dan konsol Elastic Beanstalk. Jika belum, ikuti petunjuk di [Pelajari cara memulai dengan Elastic Beanstalk](GettingStarted.md) untuk meluncurkan lingkungan Elastic Beanstalk pertama Anda.

Untuk mengikuti prosedur di panduan ini, Anda memerlukan terminal atau shell baris perintah untuk menjalankan perintah. Perintah ditampilkan dalam daftar yang diawali dengan simbol prompt (\$1) dan nama direktori saat ini, bila perlu.

```
~/eb-project$ this is a command
this is output
```

Di Linux dan macOS, Anda dapat menggunakan shell dan manajer paket pilihan Anda. Pada Windows Anda dapat [menginstal Windows Subsystem untuk Linux untuk](https://docs.microsoft.com/en-us/windows/wsl/install-win10) mendapatkan versi Windows terintegrasi dari Ubuntu dan Bash.

Dalam tutorial ini kita menggunakan Python 3.11 dan versi platform Elastic Beanstalk yang sesuai. Pasang Python dengan mengikuti petunjuk di [Menyiapkan lingkungan pengembangan Python Anda untuk Elastic Beanstalk](python-development-environment.md).

Kerangka kerja [Flask](http://flask.pocoo.org/) akan diinstal sebagai bagian dari tutorial.

Tutorial ini juga menggunakan Elastic Beanstalk Command Line Interface (EB CLI). Untuk detail dalam menginstal dan mengonfigurasi EB CLI, lihat [Instal EB CLI dengan skrip pengaturan (disarankan)](eb-cli3.md#eb-cli3-install) dan [Mengonfigurasi EB CLI](eb-cli3-configuration.md).

## Menyiapkan lingkungan virtual Python dengan Flask
<a name="python-flask-setup-venv"></a>

Membuat direktori proyek dan lingkungan virtual untuk aplikasi Anda, dan menginstal Flask.

**Untuk mempersiapkan lingkungan proyek Anda**

1. Buat direktori proyek.

   ```
   ~$ mkdir eb-flask
   ~$ cd eb-flask
   ```

1. Buat dan aktifkan lingkungan virtual bernama `virt`:

   ```
   ~/eb-flask$ virtualenv virt
   ~$ source virt/bin/activate
   (virt) ~/eb-flask$
   ```

   Anda akan melihat `(virt)` ditambahkan ke prompt perintah Anda, yang menunjukkan bahwa Anda berada di lingkungan virtual. Gunakan lingkungan virtual hingga akhir tutorial ini.

1. Pasang Flask dengan `pip install`:

   ```
   (virt)~/eb-flask$ pip install flask==3.0.3
   ```

1. Lihat perpustakaan yang diinstal dengan `pip freeze`:

   ```
   (virt)~/eb-flask$ pip freeze
   blinker==1.8.2
   click==8.1.7
   Flask==3.0.3
   importlib_metadata==8.5.0
   itsdangerous==2.2.0
   Jinja2==3.1.4
   MarkupSafe==2.1.5
   Werkzeug==3.0.4
   zipp==3.20.2
   ```

   Perintah ini mencantumkan semua paket yang diinstal di lingkungan virtual Anda. Berhubung Anda berada di lingkungan virtual, paket yang diinstal secara global seperti EB CLI tidak akan ditampilkan.

1. Simpan output dari `pip freeze` ke file bernama `requirements.txt`.

   ```
   (virt)~/eb-flask$ pip freeze > requirements.txt
   ```

   File ini meminta Elastic Beanstalk untuk menginstal perpustakaan selama deployment. Untuk informasi selengkapnya, lihat [Menentukan dependensi menggunakan file persyaratan pada Elastic Beanstalk](python-configuration-requirements.md).

## Buat aplikasi Flask
<a name="python-flask-create-app"></a>

Selanjutnya, buat aplikasi yang akan Anda deploy menggunakan Elastic Beanstalk. Kami akan membuat layanan RESTful web “Hello World”.

Buat file teks dalam direktori ini bernama `application.py` dengan isi berikut:

**Example `~/eb-flask/application.py`**  

```
from flask import Flask

# print a nice greeting.
def say_hello(username = "World"):
    return '<p>Hello %s!</p>\n' % username

# some bits of text for the page.
header_text = '''
    <html>\n<head> <title>EB Flask Test</title> </head>\n<body>'''
instructions = '''
    <p><em>Hint</em>: This is a RESTful web service! Append a username
    to the URL (for example: <code>/Thelonious</code>) to say hello to
    someone specific.</p>\n'''
home_link = '<p><a href="/">Back</a></p>\n'
footer_text = '</body>\n</html>'

# EB looks for an 'application' callable by default.
application = Flask(__name__)

# add a rule for the index page.
application.add_url_rule('/', 'index', (lambda: header_text +
    say_hello() + instructions + footer_text))

# add a rule when the page is accessed with a name appended to the site
# URL.
application.add_url_rule('/<username>', 'hello', (lambda username:
    header_text + say_hello(username) + home_link + footer_text))

# run the app.
if __name__ == "__main__":
    # Setting debug to True enables debug output. This line should be
    # removed before deploying a production app.
    application.debug = True
    application.run()
```

Contoh ini membuat penyesuaian salam pembuka yang bervariasi berdasarkan jalur yang digunakan untuk mengakses layanan.

**catatan**  
Dengan menambahkan `application.debug = True` sebelum menjalankan aplikasi, output debug diaktifkan jika seandainya ada sesuatu yang tidak beres. Hal ini merupakan penerapan yang baik untuk pengembangan, tetapi Anda harus menghapus pernyataan debug dalam kode produksi, karena output debug dapat mengungkapkan aspek internal aplikasi Anda.

Menggunakan `application.py` sebagai nama file dan memberikan objek `application` yang dapat dipanggil (objek Flask, dalam hal ini) mengizinkan Elastic Beanstalk dengan mudah untuk menemukan kode aplikasi Anda.

Jalankan `application.py` dengan Python:

```
(virt) ~/eb-flask$ python application.py
 * Serving Flask app "application" (lazy loading)
 * Environment: production
   WARNING: Do not use the development server in a production environment.
   Use a production WSGI server instead.
 * Debug mode: on
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 313-155-123
```

Buka `http://127.0.0.1:5000/` di peramban web Anda. Anda harus melihat aplikasi yang berjalan, menunjukkan halaman indeks:

![\[Web browser displaying "Hello World!" message and a hint about RESTful web service usage.\]](http://docs.aws.amazon.com/id_id/elasticbeanstalk/latest/dg/images/eb_flask_test_local.png)


Periksa log server untuk melihat output dari permintaan Anda. Anda dapat menghentikan server web dan mengembalikan ke lingkungan virtual Anda dengan mengetik **Ctrl\$1C**.

Jika Anda justru mendapati output debug, perbaiki kesalahan dan pastikan aplikasi berjalan secara lokal sebelum mengonfigurasinya untuk Elastic Beanstalk.

## Men-deploy situs Anda dengan EB CLI
<a name="python-flask-deploy"></a>

Anda telah menambahkan semua yang dibutuhkan untuk men-deploy aplikasi Anda pada Elastic Beanstalk. Direktori proyek Anda seharusnya sekarang terlihat seperti ini:

```
~/eb-flask/
|-- virt
|-- application.py
`-- requirements.txt
```

Folder `virt`, bagaimanapun, tidak diperlukan aplikasi untuk berjalan di Elastic Beanstalk. Ketika Anda men-deploy, Elastic Beanstalk akan membuat lingkungan virtual baru pada instans server dan menginstal perpustakaan yang tercantum dalam `requirements.txt`. Untuk meminimalkan ukuran paket sumber yang Anda unggah selama deployment, tambahkan file [.ebignore](eb-cli3-configuration.md#eb-cli3-ebignore) yang meminta EB CLI untuk meninggalkan folder `virt`.

**Example \$1/eb-flask/.ebignore**  

```
virt
```

Selanjutnya, Anda akan membuat lingkungan aplikasi dan men-deploy aplikasi Anda yang dikonfigurasi dengan Elastic Beanstalk.

**Untuk membuat lingkungan dan men-deploy aplikasi Flask Anda**

1. Inisialisasi repositori EB CLI Anda dengan perintah **eb init**:

   ```
   ~/eb-flask$ eb init -p python-3.11 flask-tutorial --region us-east-2
   Application flask-tutorial has been created.
   ```

   Perintah ini membuat aplikasi baru bernama `flask-tutorial` dan mengkonfigurasi repositori lokal Anda untuk membuat lingkungan dengan versi platform Python 3.11 terbaru.

1. (opsional) Jalankan **eb init** lagi untuk mengonfigurasi keypair default sehingga Anda dapat terhubung ke EC2 instance yang menjalankan aplikasi Anda dengan SSH:

   ```
   ~/eb-flask$ eb init
   Do you want to set up SSH for your instances?
   (y/n): y
   Select a keypair.
   1) my-keypair
   2) [ Create new KeyPair ]
   ```

   Pilih pasangan kunci jika Anda sudah memilikinya, atau ikuti prompt untuk membuat yang baru. Jika Anda tidak melihat prompt atau perlu mengubah pengaturan Anda nanti, jalankan **eb init -i**.

1. Buat lingkungan dan deploy aplikasi Anda ke dalamnya dengan **eb create**:

   ```
   ~/eb-flask$ eb create flask-env
   ```

Pembuatan lingkungan membutuhkan waktu sekitar 5 menit dan membuat 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.

Semua sumber daya ini dikelola oleh Elastic Beanstalk. Ketika Anda mengakhiri lingkungan, Elastic Beanstalk mengakhiri semua sumber daya yang dimuatnya.

**catatan**  
Bucket Amazon S3 yang dibuat Elastic Beanstalk dibagi antar lingkungan dan tidak dihapus selama pengakhiran lingkungan. Untuk informasi selengkapnya, lihat [Menggunakan Elastic Beanstalk dengan Amazon S3](AWSHowTo.S3.md).

Ketika proses pembuatan lingkungan selesai, buka situs web Anda dengan **eb open**:

```
~/eb-flask$ eb open
```

Ini akan membuka jendela peramban menggunakan nama domain yang dibuat untuk aplikasi Anda. Anda akan melihat situs web Flask yang sama seperti yang Anda telah buat dan uji secara lokal.

![\[Browser window displaying a Flask web application with a "Hello World!" message and usage hint.\]](http://docs.aws.amazon.com/id_id/elasticbeanstalk/latest/dg/images/eb_flask_deployed.png)


Jika aplikasi tidak berjalan, atau menerima pesan kesalahan, lihat [Pemecahan Masalah Deployment](troubleshooting.md#troubleshooting-deployments) untuk bantuan tentang cara menentukan penyebab kesalahan.

Jika Anda *benar-benar* melihat aplikasi Anda berjalan, maka selamat, Anda telah men-deploy aplikasi Flask pertama Anda dengan Elastic Beanstalk\$1

## Pembersihan
<a name="python-flask-tutorial-cleanup"></a>

Setelah Anda selesai bekerja dengan kode demo, Anda dapat mengakhiri lingkungan Anda. [Elastic Beanstalk menghapus semua sumber daya AWS terkait, [seperti instans EC2 Amazon](using-features.managing.ec2.md)[, instans database, penyeimbang beban, grup keamanan,](using-features.managing.db.md)[dan](using-features.managing.elb.md) alarm.](using-features.alarms.md#using-features.alarms.title) 

Menghapus sumber daya tidak menghapus aplikasi Elastic Beanstalk, sehingga Anda dapat membuat lingkungan baru untuk aplikasi Anda kapan saja.

**Untuk mengakhiri lingkungan Elastic Beanstalk Anda dari konsol**

1. **Buka konsol [Elastic Beanstalk, dan di daftar Wilayah, pilih konsol Elastic](https://console.aws.amazon.com/elasticbeanstalk) Beanstalk.** Wilayah AWS

1. Di panel navigasi, pilih **Lingkungan**, dan kemudian pilih nama lingkungan Anda dari daftar.

1. Pilih **Tindakan**, lalu pilih **Terminate environment**.

1. Gunakan kotak dialog di layar untuk mengonfirmasi pengakhiran lingkungan.

Atau, dengan EB CLI:

```
~/eb-flask$ eb terminate flask-env
```

## Langkah selanjutnya
<a name="python-flask-more-info"></a>

Untuk informasi lebih selengkapnya tentang Flask, kunjungi [flask.pocoo.org](http://flask.pocoo.org/).

Jika anda ingin mencoba kerangka kerja web Python lain, lihat [Men-deploy aplikasi Django ke Elastic Beanstalk](create-deploy-python-django.md).