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

# Menyebarkan aplikasi Python dengan Elastic Beanstalk
<a name="create-deploy-python-apps"></a>

Bab ini memberikan instruksi untuk mengkonfigurasi dan menyebarkan aplikasi web Python Anda ke. AWS Elastic Beanstalk Elastic Beanstalk memudahkan penerapan, pengelolaan, dan skala aplikasi web Python Anda menggunakan Amazon Web Services.

Anda dapat menerapkan aplikasi Anda hanya dalam beberapa menit menggunakan Elastic Beanstalk Command Line Interface (EB CLI) atau dengan menggunakan konsol Elastic Beanstalk. Setelah Anda menerapkan aplikasi Elastic Beanstalk Anda, Anda dapat terus menggunakan EB CLI untuk mengelola aplikasi dan lingkungan Anda, atau Anda dapat menggunakan konsol Elastic Beanstalk,, atau. AWS CLI APIs

Ikuti langkah-langkah dalam [QuickStart untuk Python](python-quickstart.md) untuk step-by-step instruksi untuk membuat dan menyebarkan aplikasi web *Python Hello* World dengan EB CLI.

**Topics**
+ [QuickStart: Menyebarkan aplikasi Python ke Elastic Beanstalk](python-quickstart.md)
+ [Menyiapkan lingkungan pengembangan Python Anda untuk Elastic Beanstalk](python-development-environment.md)
+ [Menggunakan platform Python Elastic Beanstalk](create-deploy-python-container.md)
+ [Men-deploy aplikasi Flask ke Elastic Beanstalk](create-deploy-python-flask.md)
+ [Men-deploy aplikasi Django ke Elastic Beanstalk](create-deploy-python-django.md)
+ [Menambahkan instans Amazon RDS DB ke lingkungan Python Elastic Beanstalk Anda](create-deploy-python-rds.md)
+ [Alat Python dan sumber daya](create-deploy-python-tools-resources.md)

# QuickStart: Menyebarkan aplikasi Python ke Elastic Beanstalk
<a name="python-quickstart"></a>

 QuickStart Tutorial ini memandu Anda melalui proses pembuatan aplikasi Python dan menyebarkannya ke lingkungan. AWS Elastic Beanstalk 

**Bukan untuk penggunaan produksi**  
Contoh dimaksudkan untuk demonstrasi saja. Jangan gunakan contoh aplikasi dalam produksi.

**Topics**
+ [AWS Akun Anda](#python-quickstart-aws-account)
+ [Prasyarat](#python-quickstart-prereq)
+ [Langkah 1: Buat aplikasi Python](#python-quickstart-create-app)
+ [Langkah 2: Jalankan aplikasi Anda secara lokal](#python-quickstart-run-local)
+ [Langkah 3: Menyebarkan aplikasi Python Anda dengan EB CLI](#python-quickstart-deploy)
+ [Langkah 4: Jalankan aplikasi Anda di Elastic Beanstalk](#python-quickstart-run-eb-ap)
+ [Langkah 5: Bersihkan](#go-tutorial-cleanup)
+ [AWS sumber daya untuk aplikasi Anda](#python-quickstart-eb-resources)
+ [Langkah selanjutnya](#python-quickstart-next-steps)
+ [Terapkan dengan konsol Elastic Beanstalk](#python-quickstart-console)

## AWS Akun Anda
<a name="python-quickstart-aws-account"></a>

Jika Anda belum menjadi AWS pelanggan, Anda perlu membuat AWS akun. Mendaftar memungkinkan Anda mengakses Elastic Beanstalk AWS dan layanan lain yang Anda butuhkan.

Jika Anda sudah memiliki AWS akun, Anda dapat melanjutkan ke[Prasyarat](#python-quickstart-prereq).

### Buat AWS akun
<a name="python-quickstart-aws-account-procedure"></a>

#### Mendaftar untuk Akun AWS
<a name="sign-up-for-aws"></a>

Jika Anda tidak memiliki Akun AWS, selesaikan langkah-langkah berikut untuk membuatnya.

**Untuk mendaftar untuk Akun AWS**

1. Buka [https://portal.aws.amazon.com/billing/pendaftaran.](https://portal.aws.amazon.com/billing/signup)

1. Ikuti petunjuk online.

   Bagian dari prosedur pendaftaran melibatkan menerima panggilan telepon atau pesan teks dan memasukkan kode verifikasi pada keypad telepon.

   Saat Anda mendaftar untuk sebuah Akun AWS, sebuah *Pengguna root akun AWS*dibuat. Pengguna root memiliki akses ke semua Layanan AWS dan sumber daya di akun. Sebagai praktik keamanan terbaik, tetapkan akses administratif ke pengguna, dan gunakan hanya pengguna root untuk melakukan [tugas yang memerlukan akses pengguna root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

AWS mengirimi Anda email konfirmasi setelah proses pendaftaran selesai. Kapan saja, Anda dapat melihat aktivitas akun Anda saat ini dan mengelola akun Anda dengan masuk [https://aws.amazon.com.rproxy.goskope.comke/](https://aws.amazon.com/) dan memilih **Akun Saya**.

#### Buat pengguna dengan akses administratif
<a name="create-an-admin"></a>

Setelah Anda mendaftar Akun AWS, amankan Pengguna root akun AWS, aktifkan AWS IAM Identity Center, dan buat pengguna administratif sehingga Anda tidak menggunakan pengguna root untuk tugas sehari-hari.

**Amankan Pengguna root akun AWS**

1.  Masuk ke [Konsol Manajemen AWS](https://console.aws.amazon.com/)sebagai pemilik akun dengan memilih **pengguna Root** dan memasukkan alamat Akun AWS email Anda. Di laman berikutnya, masukkan kata sandi.

   Untuk bantuan masuk dengan menggunakan pengguna root, lihat [Masuk sebagai pengguna root](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) di *AWS Sign-In Panduan Pengguna*.

1. Mengaktifkan autentikasi multi-faktor (MFA) untuk pengguna root Anda.

   Untuk petunjuk, lihat [Mengaktifkan perangkat MFA virtual untuk pengguna Akun AWS root (konsol) Anda](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) di Panduan Pengguna *IAM*.

**Buat pengguna dengan akses administratif**

1. Aktifkan Pusat Identitas IAM.

   Untuk mendapatkan petunjuk, silakan lihat [Mengaktifkan AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) di *Panduan Pengguna AWS IAM Identity Center *.

1. Di Pusat Identitas IAM, berikan akses administratif ke pengguna.

   Untuk tutorial tentang menggunakan Direktori Pusat Identitas IAM sebagai sumber identitas Anda, lihat [Mengkonfigurasi akses pengguna dengan default Direktori Pusat Identitas IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) di *Panduan AWS IAM Identity Center Pengguna*.

**Masuk sebagai pengguna dengan akses administratif**
+ Untuk masuk dengan pengguna Pusat Identitas IAM, gunakan URL masuk yang dikirim ke alamat email saat Anda membuat pengguna Pusat Identitas IAM.

  Untuk bantuan masuk menggunakan pengguna Pusat Identitas IAM, lihat [Masuk ke portal AWS akses](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) di *Panduan AWS Sign-In Pengguna*.

**Tetapkan akses ke pengguna tambahan**

1. Di Pusat Identitas IAM, buat set izin yang mengikuti praktik terbaik menerapkan izin hak istimewa paling sedikit.

   Untuk petunjuknya, lihat [Membuat set izin](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) di *Panduan AWS IAM Identity Center Pengguna*.

1. Tetapkan pengguna ke grup, lalu tetapkan akses masuk tunggal ke grup.

   Untuk petunjuk, lihat [Menambahkan grup](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) di *Panduan AWS IAM Identity Center Pengguna*.

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

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.

### EB CLI
<a name="python-quickstart-prereq.ebcli"></a>

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

### Kerangka kerja Python dan Flask
<a name="python-quickstart-prereq.runtime"></a>

Konfirmasikan bahwa Anda memiliki versi Python yang berfungsi dengan `pip` diinstal dengan menjalankan perintah berikut.

```
~$ python3 --version
Python 3.N.N
>~$ python3 -m pip --version
pip X.Y.Z from ... (python 3.N.N)
```

Jika salah satu perintah sebelumnya mengembalikan “*Python tidak ditemukan* “, jalankan perintah berikut yang menggunakan `python` alih-alih. `python3` Pengaturan alias dan tautan simbolik dapat bervariasi menurut sistem operasi dan penyesuaian individual, sehingga `python3` perintah mungkin tidak berfungsi pada mesin Anda.

```
~$ python --version
Python 3.N.N
>~$ python -m pip --version
pip X.Y.Z from ... (python 3.N.N)
```

Jika Anda tidak menginstal Python di komputer lokal Anda, Anda dapat mengunduhnya dari halaman unduhan Python di [situs web Python](https://www.python.org/downloads/). *Untuk daftar versi bahasa Python yang didukung oleh Elastic Beanstalk, [lihat Platform Python yang didukung](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python) dalam panduan Platform.AWS Elastic Beanstalk * Situs web unduhan Python menyediakan tautan ke *Panduan Pengembang Python*, tempat Anda akan menemukan instruksi instalasi dan penyiapan.

**catatan**  
`pip`Paket Python disertakan secara default dengan Python 3.4 atau yang lebih baru.

Jika output Anda menunjukkan bahwa Anda memiliki versi Python yang didukung, tetapi tidak`pip`, lihat halaman [Instalasi](https://pip.pypa.io/en/stable/installation/) di situs web *pip.pypa.io*. Ini memberikan panduan untuk menginstal pip dalam lingkungan Python yang tidak memilikinya.



Konfirmasikan apakah Flask diinstal dengan menjalankan perintah berikut:

```
~$ pip list | grep Flask
```

Jika Flask tidak diinstal, Anda dapat menginstalnya dengan perintah berikut:

```
~$ pip install Flask
```

## Langkah 1: Buat aplikasi Python
<a name="python-quickstart-create-app"></a>

Buat direktori proyek.

```
~$ mkdir eb-python
~$ cd eb-python
```

Buat sampel “Halo Elastic Beanstalk\$1” Aplikasi Python yang akan Anda gunakan menggunakan Elastic Beanstalk.

Buat file teks bernama `application.py` di direktori yang baru saja Anda buat dengan konten berikut.

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

```
from flask import Flask
application = Flask(__name__)

@application.route('/')
def hello_elastic_beanstalk():
        return 'Hello Elastic Beanstalk!'
```

Buat file teks bernama `requirements.txt` dengan baris berikut. File ini berisi `pip` paket yang diperlukan untuk menjalankan aplikasi.

**Example `~/eb-python/requirements.txt`**  

```
Flask
```

## Langkah 2: Jalankan aplikasi Anda secara lokal
<a name="python-quickstart-run-local"></a>

Jalankan perintah berikut untuk menjalankan aplikasi Anda secara lokal.

```
~/eb-python$ export FLASK_APP=application.py && flask run --port 5000
```

Anda akan melihat output yang mirip dengan berikut

```
Serving Flask app 'application.py'
Debug mode: off
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
Running on http://127.0.0.1:5000
Press CTRL+C to quit
127.0.0.1 - - [01/Jan/1970 00:00:00] "GET / HTTP/1.1" 200 -
```

Arahkan ke `http://localhost:5000` di browser web Anda. Browser web harus menampilkan “Hello Elastic Beanstalk\$1”.

## Langkah 3: Menyebarkan aplikasi Python Anda dengan EB CLI
<a name="python-quickstart-deploy"></a>

Jalankan perintah berikut untuk membuat lingkungan Elastic Beanstalk untuk aplikasi ini.

 

**Untuk membuat lingkungan dan menyebarkan aplikasi Python Anda**

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

   ```
   ~/eb-python$ eb init -p python-3.9 python-tutorial --region us-east-2
   ```

   Perintah ini membuat aplikasi bernama `python-tutorial` dan mengkonfigurasi repositori lokal Anda untuk membuat lingkungan dengan versi platform Python yang disediakan.

1. (Opsional) Jalankan **eb init** lagi untuk mengonfigurasi pasangan kunci default, sehingga Anda dapat menggunakan SSH untuk terhubung ke instans EC2 yang menjalankan aplikasi Anda.

   ```
   ~/eb-python$ 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 membuatnya. Jika Anda tidak melihat prompt atau perlu mengubah pengaturan Anda nanti, jalankan **eb init -i**.

1. Buat lingkungan baru dan deploy aplikasi Anda dengan **eb create**. Elastic Beanstalk secara otomatis membuat file zip untuk aplikasi Anda dan memulainya pada port 5000.

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

   Dibutuhkan sekitar lima menit untuk Elastic Beanstalk untuk menciptakan lingkungan Anda.

## Langkah 4: Jalankan aplikasi Anda di Elastic Beanstalk
<a name="python-quickstart-run-eb-ap"></a>

Ketika proses untuk membuat lingkungan Anda selesai, buka situs web Anda dengan**eb open**.

```
~/eb-python$ eb open
```

Selamat\$1 Anda telah menerapkan aplikasi Python dengan Elastic Beanstalk\$1 Ini akan membuka jendela peramban menggunakan nama domain yang dibuat untuk aplikasi Anda.

## Langkah 5: Bersihkan
<a name="go-tutorial-cleanup"></a>

Anda dapat menghentikan lingkungan Anda ketika Anda selesai bekerja dengan aplikasi Anda. Elastic Beanstalk AWS mengakhiri semua sumber daya yang terkait dengan lingkungan Anda.

Untuk mengakhiri lingkungan Elastic Beanstalk Anda dengan EB CLI jalankan perintah berikut.

```
~/eb-python$ eb terminate
```

## AWS sumber daya untuk aplikasi Anda
<a name="python-quickstart-eb-resources"></a>

Anda baru saja membuat aplikasi instance tunggal. Ini berfungsi sebagai aplikasi sampel langsung dengan satu instans EC2, sehingga tidak memerlukan penyeimbangan beban atau penskalaan otomatis. Untuk aplikasi contoh tunggal Elastic Beanstalk menciptakan sumber daya berikut: AWS 
+ **Instans EC2** – Mesin virtual Amazon EC2 yang dikonfigurasi untuk menjalankan aplikasi web di platform yang Anda pilih.

  Setiap platform menjalankan satu set perangkat lunak, file konfigurasi, dan penulisan yang berbeda 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 memproses lalu lintas web di depan aplikasi web Anda, meneruskan permintaan ke aplikasi web, menyajikan aset statis, dan menghasilkan log akses dan kesalahan.
+ **Grup keamanan instans** – Grup keamanan Amazon EC2 yang dikonfigurasi untuk mengizinkan lalu lintas masuk di port 80. Sumber daya ini memungkinkan lalu lintas HTTP dari penyeimbang beban mencapai instans EC2 yang menjalankan aplikasi web Anda. Secara default, lalu lintas tidak diizinkan di port lain.
+ **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 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*. 

Elastic Beanstalk mengelola semua sumber daya tersebut. Ketika Anda mengakhiri lingkungan, Elastic Beanstalk mengakhiri semua sumber daya yang dimuatnya.

## Langkah selanjutnya
<a name="python-quickstart-next-steps"></a>

Setelah lingkungan Anda menjalankan aplikasi, Anda dapat men-deploy versi baru aplikasi atau aplikasi yang berbeda kapan saja. Men-deploy versi aplikasi baru itu sangat cepat karena tidak memerlukan persediaan atau memulai ulang instans EC2. Anda juga dapat menjelajahi lingkungan baru Anda menggunakan konsol Elastic Beanstalk. Untuk langkah-langkah mendetail, lihat [Menjelajahi lingkungan Anda](GettingStarted.md#GettingStarted.Explore) di bagian *Memulai* panduan ini.

**Coba lebih banyak tutorial**  
Jika Anda ingin mencoba tutorial lain dengan aplikasi contoh yang berbeda, lihat tutorial berikut:  
[Men-deploy aplikasi Flask ke Elastic Beanstalk](create-deploy-python-flask.md)
[Men-deploy aplikasi Django ke Elastic Beanstalk](create-deploy-python-django.md)

Setelah Anda menerapkan satu atau dua contoh aplikasi dan siap untuk mulai mengembangkan dan menjalankan aplikasi Python secara lokal, lihat. [Menyiapkan lingkungan pengembangan Python Anda untuk Elastic Beanstalk](python-development-environment.md) 

## Terapkan dengan konsol Elastic Beanstalk
<a name="python-quickstart-console"></a>

Anda juga dapat menggunakan konsol Elastic Beanstalk untuk meluncurkan aplikasi sampel. Untuk langkah-langkah rinci, lihat [Membuat aplikasi contoh](GettingStarted.md#GettingStarted.CreateApp) di Bab *Memulai* panduan ini.

# Menyiapkan lingkungan pengembangan Python Anda untuk Elastic Beanstalk
<a name="python-development-environment"></a>

Topik ini memberikan instruksi untuk menyiapkan lingkungan pengembangan Python untuk menguji aplikasi Anda secara lokal sebelum menerapkannya. AWS Elastic Beanstalk Ini juga merujuk situs web yang menyediakan instruksi instalasi untuk alat yang berguna.

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.

**Topics**
+ [Prasyarat](#python-common-prereq)
+ [Menggunakan lingkungan virtual](#python-common-setup-venv)
+ [Mengonfigurasi proyek Python pada Elastic Beanstalk](#python-common-configuring)

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

Daftar berikut memberikan prasyarat umum untuk bekerja dengan Elastic Beanstalk dan aplikasi Python Anda:
+ Bahasa **Python - Instal versi bahasa** Python yang disertakan pada versi platform Elastic Beanstalk Python pilihan Anda. *Untuk daftar versi bahasa Python yang didukung, lihat Platform [Python yang didukung dalam panduan Platform](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python).AWS Elastic Beanstalk * Jika Anda belum menyiapkan Python di mesin pengembangan Anda, lihat halaman [unduhan Python di situs web Python](https://www.python.org/downloads/).
+ **`pip`utilitas** — `pip` Utilitas adalah penginstal paket Python. Ini menginstal dan mencantumkan dependensi untuk proyek Anda, sehingga Elastic Beanstalk tahu cara mengatur lingkungan aplikasi Anda. Untuk informasi selengkapnya`pip`, lihat [halaman pip di situs](https://pip.pypa.io/en/stable/) web *pip.pypa.io*.
+ **(Opsional) Antarmuka Baris Perintah Elastic Beanstalk (EB CLI) - CLI** [EB dapat mengemas aplikasi Anda dengan](eb-cli3.md) file penerapan yang diperlukan. Itu juga dapat membuat lingkungan Elastic Beanstalk dan menyebarkan aplikasi Anda ke sana. Anda juga dapat melakukan penerapan melalui konsol Elastic Beanstalk, sehingga EB CLI tidak sepenuhnya diperlukan.
+ **`SSH`Instalasi yang berfungsi** — Anda dapat terhubung ke instance yang sedang berjalan dengan protokol SSH untuk memeriksa atau men-debug penerapan.
+ **`virtualenv`paket** — `virtualenv` Alat ini menciptakan lingkungan pengembangan dan pengujian untuk aplikasi Anda. Elastic Beanstalk dapat mereplikasi lingkungan ini tanpa menginstal paket tambahan yang tidak diperlukan oleh aplikasi Anda. Untuk informasi lebih lanjut, lihat situs web [virtualenv](https://virtualenv.pypa.io/en/latest/). Setelah menginstal Python, Anda dapat menginstal `virtualenv` paket dengan perintah berikut:

  ```
  $ pip install virtualenv
  ```

## Menggunakan lingkungan virtual
<a name="python-common-setup-venv"></a>

Setelah prasyarat telah diinstal, siapkan lingkungan virtual dengan `virtualenv` untuk menginstal dependensi aplikasi Anda. Dengan menggunakan lingkungan virtual, Anda dapat membedakan dengan tepat paket mana yang dibutuhkan oleh aplikasi Anda sehingga paket yang diperlukan diinstal pada EC2 instance yang menjalankan aplikasi Anda.

**Untuk menyiapkan lingkungan virtual**

1. Buka jendela baris-perintah dan ketik:

   ```
   $ virtualenv /tmp/eb_python_app
   ```

   Ganti *eb\$1python\$1app* dengan nama yang masuk akal untuk aplikasi Anda (menggunakan nama aplikasi Anda adalah ide yang bagus). Perintah `virtualenv` membuat lingkungan virtual untuk Anda dalam direktori tertentu dan mencetak hasil dari tindakannya:

   ```
   Running virtualenv with interpreter /usr/bin/python
   New python executable in /tmp/eb_python_app/bin/python3.12
   Also creating executable in /tmp/eb_python_app/bin/python
   Installing setuptools, pip...done.
   ```

1. Setelah lingkungan virtual Anda siap, mulai dengan menjalankan skrip `activate` yang terletak di direktori `bin` lingkungan tersebut. Misalnya, untuk memulai lingkungan **eb\$1python\$1app** yang dibuat di langkah sebelumnya, Anda akan mengetik:

   ```
   $ source /tmp/eb_python_app/bin/activate
   ```

   Lingkungan virtual mencetak namanya (misalnya: `(eb_python_app)`) di awal setiap prompt perintah, mengingatkan bahwa Anda berada di lingkungan Python virtual.

1. Untuk berhenti menggunakan lingkungan virtual Anda dan kembali ke juru bahasa Python default sistem dengan semua perpustakaan terinstal, jalankan perintah `deactivate`.

   ```
   (eb_python_app) $ deactivate
   ```

**catatan**  
Setelah dibuat, Anda dapat menghidupkan ulang lingkungan virtual kapan pun itu dengan menjalankan skrip `activate` kembali.

## Mengonfigurasi proyek Python pada Elastic Beanstalk
<a name="python-common-configuring"></a>

Anda dapat menggunakan CLI Elastic Beanstalk untuk mempersiapkan aplikasi Python Anda untuk deployment dengan menggunakan Elastic Beanstalk.

**Untuk mengonfigurasi aplikasi Python untuk deployment dengan menggunakan Elastic Beanstalk**

1. Dari dalam [lingkungan virtual](#python-common-setup-venv), kembali ke bagian atas direktori berstruktur pohon milik proyek (`python_eb_app`) Anda, dan ketik:

   ```
   pip freeze >requirements.txt
   ```

   Perintah ini menyalin nama dan versi paket yang diinstal di lingkungan virtual Anda ke`requirements.txt`, Misalnya, jika paket *PyYaml*, *versi* 3.11 diinstal di lingkungan virtual Anda, file akan berisi baris:

   ```
   PyYAML==3.11
   ```

   Hal ini mengizinkan Elastic Beanstalk meniru lingkungan Python aplikasi Anda menggunakan paket dan versi sama yang biasa mengembangkan dan menguji aplikasi Anda.

1. Konfigurasi repositori EB CLI dengan perintah **eb init**. Ikuti prompt untuk memilih wilayah, platform, dan opsi lainnya.

Secara default, Elastic Beanstalk mencari file bernama `application.py` untuk memulai aplikasi Anda. Jika ini tidak ada dalam proyek Python yang telah Anda buat, diperlukan beberapa penyesuaian lingkungan aplikasi Anda. Anda juga perlu mengatur variabel lingkungan sehingga modul aplikasi Anda dapat dimuat. Lihat [Menggunakan platform Python Elastic Beanstalk](create-deploy-python-container.md) untuk informasi selengkapnya.

# Menggunakan platform Python Elastic Beanstalk
<a name="create-deploy-python-container"></a>

Topik ini menjelaskan cara mengonfigurasi, membangun, dan menjalankan aplikasi Python Anda di Elastic Beanstalk.

AWS Elastic Beanstalk mendukung sejumlah cabang platform untuk berbagai versi bahasa pemrograman Python. Lihat [Python](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python) di dokumen *AWS Elastic Beanstalk Platform* untuk daftar lengkapnya.

Aplikasi web Python dapat berjalan di belakang server proxy dengan WSGI. Elastic [Beanstalk](https://gunicorn.org/) menyediakan Gunicorn sebagai server WSGI default. 

Anda dapat menambahkan `Procfile` ke paket sumber untuk menentukan dan mengonfigurasi server WSGI bagi aplikasi Anda. Untuk detail selengkapnya, lihat [Mengkonfigurasi server WSGI dengan Procfile pada Elastic Beanstalk](python-configuration-procfile.md).

Anda dapat menggunakan file `Pipfile` dan `Pipfile.lock` yang dibuat oleh Pipenv untuk menentukan dependensi paket Python dan persyaratan lainnya. Untuk detail tentang menentukan dependensi, lihat [Menentukan dependensi menggunakan file persyaratan pada Elastic Beanstalk](python-configuration-requirements.md).

Elastic [Beanstalk menyediakan](command-options.md) opsi konfigurasi yang dapat Anda gunakan untuk menyesuaikan perangkat lunak yang berjalan EC2 pada instance di lingkungan Elastic Beanstalk Anda. Anda dapat mengonfigurasi variabel lingkungan yang diperlukan aplikasi Anda, mengaktifkan rotasi log ke Amazon S3, dan memetakan folder dalam sumber aplikasi Anda yang berisi file statis ke jalur yang disajikan server proksi.

Opsi konfigurasi tersedia di konsol Elastic Beanstalk untuk [memodifikasi konfigurasi dari lingkungan yang sedang berjalan](environment-configuration-methods-after.md). Agar Anda tidak kehilangan konfigurasi lingkungan ketika mengakhirinya, Anda dapat menggunakan [konfigurasi tersimpan](environment-configuration-savedconfig.md) untuk menyimpan pengaturan dan kemudian menerapkannya ke lingkungan lain.

Untuk menyimpan pengaturan di kode sumber, Anda dapat menyertakan [file konfigurasi](ebextensions.md). Pengaturan di file konfigurasi diterapkan setiap kali Anda membuat lingkungan atau men-deploy aplikasi Anda. Anda juga dapat menggunakan file konfigurasi untuk menginstal paket, menjalankan penulisan, dan melakukan operasi penyesuaian instans lainnya selama deployment.

Pengaturan yang diterapkan di konsol Elastic Beanstalk mengganti pengaturan yang sama di file konfigurasi, jika ada. Hal tersebut memungkinkan Anda memiliki pengaturan default di file konfigurasi, dan mengganti keduanya dengan pengaturan khusus lingkungan di konsol tersebut. Untuk informasi lebih lanjut tentang yang diutamakan, dan metode lain untuk mengubah pengaturan, lihat [Opsi konfigurasi](command-options.md).

Untuk paket Python tersedia dari `pip`, Anda dapat menyertakan file persyaratan di akar kode sumber aplikasi Anda. Elastic Beanstalk menginstal paket dependensi yang ditentukan dalam file persyaratan selama deployment. Untuk detail selengkapnya, lihat [Menentukan dependensi menggunakan file persyaratan pada Elastic Beanstalk](python-configuration-requirements.md).

Untuk detail tentang berbagai cara memperluas platform berbasis Linux Elastic Beanstalk, lihat [Memperluas platform Linux Elastic Beanstalk](platforms-linux-extend.md).

## Mengonfigurasi lingkungan Python Anda
<a name="create-deploy-python-container-console"></a>

Pengaturan platform Python memungkinkan Anda menyempurnakan perilaku instans Amazon Anda. EC2 Anda dapat mengedit konfigurasi instans Amazon lingkungan Elastic Beanstalk menggunakan konsol EC2 Elastic Beanstalk.

Gunakan konsol Elastic Beanstalk untuk mengonfigurasi AWS X-Ray pengaturan proses Python, mengaktifkan, mengaktifkan rotasi log ke Amazon S3, dan mengonfigurasi variabel yang dapat dibaca aplikasi Anda dari lingkungan.

**Untuk mengonfigurasi lingkungan Python Anda di konsol Elastic Beanstalk**

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. Pada panel navigasi, pilih **Konfigurasi**.

1. Dalam kategori konfigurasi **Pembaruan, pemantauan, dan pencatatan**, pilih **Edit**.

### Pengaturan Python
<a name="python-console-settings"></a>
+ **Server proksi** – Server proksi yang akan digunakan pada instans lingkungan Anda. Secara default, nginx digunakan.
+ **Jalur WSGI** – Nama atau jalur ke file aplikasi utama Anda. Misalnya, `application.py`, atau `django/wsgi.py`.
+ **NumProcesses**— Jumlah proses yang dijalankan pada setiap instance aplikasi.
+ **NumThreads**— Jumlah thread yang akan dijalankan di setiap proses.

### AWS X-Ray pengaturan
<a name="python-console-xray"></a>
+ **Daemon X-Ray** - Jalankan AWS X-Ray daemon untuk memproses data jejak dari. [AWS X-Ray SDK for Python](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html)

### Opsi log
<a name="create-deploy-python-container.console.logoptions"></a>

Bagian Opsi Log memiliki dua pengaturan:
+ **Profil instans**– Menentukan profil instans yang memiliki izin untuk mengakses bucket Amazon S3 yang terkait dengan aplikasi Anda.
+ **Aktifkan rotasi file log ke Amazon S3** — Menentukan apakah file log untuk EC2 instans Amazon aplikasi Anda disalin ke bucket Amazon S3 yang terkait dengan aplikasi Anda.

### File statis
<a name="python-platform-staticfiles"></a>

Untuk meningkatkan kinerja, Anda dapat menggunakan bagian **File statis** untuk mengkonfigurasi server proxy untuk melayani file statis (misalnya, HTML atau gambar) dari satu set direktori di dalam aplikasi web Anda. Untuk setiap direktori, Anda mengatur jalur virtual ke pemetaan direktori. Saat server proksi menerima permintaan untuk file di jalur yang ditentukan, server langsung menyajikan file daripada merutekan permintaan ke aplikasi Anda.

Untuk detail tentang mengonfigurasi file statis menggunakan file konfigurasi atau konsol Elastic Beanstalk, lihat. [Menyajikan file statis](environment-cfg-staticfiles.md)

Secara default, server proksi di lingkungan Python menyajikan file apa pun dalam folder bernama `static` di jalur `/static`. Misalnya, jika sumber aplikasi Anda berisi file bernama `logo.png` dalam folder bernama `static`, server proksi menyajikannya untuk pengguna di `subdomain.elasticbeanstalk.com/static/logo.png`. Anda dapat mengonfigurasi pemetaan tambahan seperti yang dijelaskan di bagian ini.

### Properti lingkungan
<a name="create-deploy-python-custom-container-envprop"></a>

Anda dapat menggunakan properti lingkungan untuk memberikan informasi ke aplikasi Anda dan mengonfigurasi variabel lingkungan. Misalnya, Anda dapat membuat properti lingkungan bernama `CONNECTION_STRING` yang menentukan string koneksi yang dapat digunakan aplikasi Anda agar terhubung ke basis data.

Di dalam lingkungan Python yang berjalan di Elastic Beanstalk, nilai-nilai ini dapat diakses menggunakan kamus `os.environ` Python. Untuk informasi lebih lanjut, lihat [http://docs.python. org/library/os.html](http://docs.python.org/library/os.html).

Anda dapat menggunakan kode yang terlihat mirip dengan yang berikut untuk mengakses kunci dan parameter:

```
import os
endpoint = os.environ['API_ENDPOINT']
```

Properti lingkungan juga dapat memberikan informasi ke kerangka kerja. Misalnya, Anda dapat membuat properti bernama `DJANGO_SETTINGS_MODULE` untuk mengonfigurasi Django agar menggunakan modul pengaturan khusus. Bergantung pada lingkungan, nilai bisa saja `development.settings`, `production.settings`, dll.

Lihat [Variabel lingkungan dan pengaturan perangkat lunak lainnya](environments-cfg-softwaresettings.md) untuk informasi selengkapnya.

## Namespace konfigurasi Python
<a name="python-namespaces"></a>

Anda dapat menggunakan [file konfigurasi](ebextensions.md) untuk mengatur opsi konfigurasi dan melakukan tugas-tugas konfigurasi instans lain selama deployment. Opsi konfigurasi dapat berupa [platform khusus](command-options-specific.md) atau berlaku untuk [semua platform di layanan](command-options-general.md) Elastic Beanstalk secara keseluruhan. Opsi konfigurasi diatur ke dalam *ruang nama*.

Platform Python mendefinisikan opsi dalam namespace `aws:elasticbeanstalk:environment:proxy`, `aws:elasticbeanstalk:environment:proxy:staticfiles`, dan `aws:elasticbeanstalk:container:python`.

File konfigurasi contoh berikut menentukan pengaturan opsi konfigurasi untuk membuat properti lingkungan bernama `DJANGO_SETTINGS_MODULE`, memilih server proksi Apache, menentukan dua opsi file statis yang memetakan direktori bernama `statichtml` ke jalur `/html` dan sebuah direktori bernama `staticimages` ke jalur `/images`, dan menentukan pengaturan tambahan di namespace `[aws:elasticbeanstalk:container:python](command-options-specific.md#command-options-python)`. Namespace ini berisi opsi yang memungkinkan Anda menentukan lokasi skrip WSGI dalam kode sumber Anda, dan jumlah utas serta proses untuk berjalan di WSGI.

```
option_settings:
  aws:elasticbeanstalk:application:environment:
    DJANGO_SETTINGS_MODULE: production.settings
  aws:elasticbeanstalk:environment:proxy:
    ProxyServer: apache
  aws:elasticbeanstalk:environment:proxy:staticfiles:
    /html: statichtml
    /images: staticimages
  aws:elasticbeanstalk:container:python:
    WSGIPath: ebdjango.wsgi:application
    NumProcesses: 3
    NumThreads: 20
```

**Catatan**  
Jika Anda menggunakan versi platform Python Amazon Linux AMI (Amazon Linux 2 yang terdahulu), ganti nilai `WSGIPath` dengan `ebdjango/wsgi.py`. Nilai dalam contoh berfungsi dengan menggunakan server Gunicorn WSGI, yang tidak didukung pada versi platform Amazon Linux AMI.
Selain itu, versi platform yang lebih lama ini menggunakan namespace yang berbeda dalam mengonfigurasi file statis—`aws:elasticbeanstalk:container:python:staticfiles`. Platform tersebut memiliki nama opsi dan makna yang sama dengan namespace file statis standar.

File konfigurasi juga mendukung beberapa kunci untuk [memodifikasi perangkat lunak lebih lanjut pada instans lingkungan Anda](customize-containers-ec2.md). Contoh ini menggunakan kunci [paket](customize-containers-ec2.md#linux-packages) untuk menginstal Memcached dengan `yum` dan [perintah kontainer](customize-containers-ec2.md#linux-container-commands) untuk menjalankan perintah yang mengonfigurasi server selama deployment:

```
packages:
  yum:
    libmemcached-devel: '0.31'

container_commands:
  collectstatic:
    command: "django-admin.py collectstatic --noinput"
  01syncdb:
    command: "django-admin.py syncdb --noinput"
    leader_only: true
  02migrate:
    command: "django-admin.py migrate"
    leader_only: true
  03wsgipass:
    command: 'echo "WSGIPassAuthorization On" >> ../wsgi.conf'
  99customize:
    command: "scripts/customize.sh"
```

Elastic Beanstalk memberikan banyak opsi konfigurasi untuk menyesuaikan lingkungan Anda. Selain file konfigurasi, Anda juga dapat mengatur opsi konfigurasi menggunakan konsol tersebut, konfigurasi tersimpan, EB CLI, atau AWS CLI. Untuk informasi selengkapnya, lihat [Opsi konfigurasi](command-options.md).

## Yang dapat `python3` dieksekusi
<a name="python3-executable"></a>

Versi `python3` executable yang tersedia pada EC2 instance di lingkungan Elastic Beanstalk Python tidak akan selalu sesuai dengan versi Python yang sama yang digunakan oleh platform. Misalnya, pada platform Python 3.12 AL2 023, menunjuk `/usr/bin/python3` ke Python 3.9. Ini karena Python 3.9 adalah sistem *Python* pada 023. AL2 Untuk informasi selengkapnya, lihat [Python di AL2 023 di Panduan](https://docs.aws.amazon.com/linux/al2023/ug/python.html) Pengguna *Amazon Linux 2023*. Anda dapat mengakses executable yang sesuai dengan versi Python yang digunakan oleh platform di lokasi berversi (misalnya`/usr/bin/python3.12`) atau di direktori lingkungan virtual aplikasi (misalnya). `bin` `/var/app/venv/staging-LQM1lest/bin/python3` Platform menggunakan executable Python yang benar yang sesuai dengan cabang platform. 

# Mengkonfigurasi server WSGI dengan Procfile pada Elastic Beanstalk
<a name="python-configuration-procfile"></a>

Anda dapat menambahkan [`Procfile`](platforms-linux-extend.build-proc.md#platforms-linux-extend.proc) ke paket sumber untuk menentukan dan mengonfigurasi server WSGI bagi aplikasi Anda. Anda dapat menentukan perintah mulai dan menjalankan kustom di`Procfile`.

Anda menggunakan `Procfile`, maka akan mengganti opsi namespace `aws:elasticbeanstalk:container:python` yang ditetapkan menggunakan file konfigurasi.

Contoh berikut menggunakan `Procfile` untuk menentukan uWSGI sebagai server dan mengonfigurasinya.

**Example Procfile**  

```
web: uwsgi --http :8000 --wsgi-file application.py --master --processes 4 --threads 2
```

Contoh berikut menggunakan `Procfile` untuk mengonfigurasi Gunicorn, server WSGI default.

**Example Procfile**  

```
web: gunicorn --bind :8000 --workers 3 --threads 2 project.wsgi:application
```

**Catatan**  
Jika Anda mengonfigurasi server WSGI selain Gunicorn, pastikan untuk menentukannya juga sebagai dependensi aplikasi Anda, sehingga terinstal pada instans lingkungan Anda. Untuk detail tentang spesifikasi dependensi, lihat [Menentukan dependensi menggunakan file persyaratan pada Elastic Beanstalk](python-configuration-requirements.md).
Port default untuk server WSGI adalah 8000. Jika Anda menentukan nomor port yang berbeda di perintah `Procfile` Anda, mengatur [properti lingkungan](environments-cfg-softwaresettings.md) `PORT` ke nomor port ini juga.

# Menentukan dependensi menggunakan file persyaratan pada Elastic Beanstalk
<a name="python-configuration-requirements"></a>

Topik ini menjelaskan cara mengkonfigurasi aplikasi Anda untuk menginstal paket Python lain yang diperlukan. Aplikasi Python tipikal memiliki dependensi pada paket Python pihak ketiga lainnya. Dengan platform Elastic Beanstalk Python, Anda memiliki beberapa cara untuk menentukan paket Python yang bergantung pada aplikasi Anda.

## Gunakan `pip` dan `requirements.txt`
<a name="python-configuration-requirements.txt"></a>

Alat standar untuk memasang paket Python adalah `pip`. Alat ini memiliki fitur yang memungkinkan Anda untuk menentukan semua paket yang Anda butuhkan (dan juga versinya) dalam satu file persyaratan. Untuk informasi selengkapnya tentang file persyaratan, lihat [Format File Persyaratan](https://pip.pypa.io/en/latest/reference/requirements-file-format/#requirements-file-format) di situs web dokumentasi pip.

Buat file bernama `requirements.txt` dan letakkan di direktori tingkat atas dari paket sumber Anda. Berikut ini adalah contoh file `requirements.txt` untuk Django.

```
Django==2.2
mysqlclient==2.0.3
```

Di lingkungan pengembangan, Anda dapat menggunakan perintah `pip freeze` untuk menghasilkan file persyaratan Anda.

```
~/my-app$ pip freeze > requirements.txt
```

Untuk memastikan bahwa file persyaratan Anda hanya berisi paket yang benar-benar digunakan oleh aplikasi Anda, gunakan [lingkungan virtual](python-development-environment.md#python-common-setup-venv) yang hanya menginstal paket tersebut. Di luar lingkungan virtual, output dari `pip freeze` akan menyertakan semua paket `pip` yang diinstal pada mesin pengembangan Anda, termasuk yang disertakan pada sistem operasi Anda.

**catatan**  
Pada versi platform Python Amazon Linux AMI, Elastic Beanstalk aslinya tidak mendukung Pipenv atau Pipfiles. Jika Anda menggunakan Pipenv untuk mengelola dependensi aplikasi Anda, jalankan perintah berikut untuk menghasilkan file `requirements.txt`.  

```
~/my-app$ pipenv lock -r > requirements.txt
```
Untuk mempelajari selengkapnya, lihat [Menghasilkan requirements.txt](https://pipenv.readthedocs.io/en/latest/advanced/#generating-a-requirements-txt) dalam dokumentasi Pipenv.

## Gunakan Pipenv dan `Pipfile`
<a name="python-configuration-requirements.pipenv"></a>

Pipenv adalah alat pengemasan Python modern. Alat tersebut mengombinasikan instalasi paket dengan pembuatan dan pengelolaan file dependensi dan virtualenv untuk aplikasi Anda. Untuk informasi lebih lanjut, lihat [Pipenv: Alur Kerja Python Dev untuk Manusia](https://pipenv.readthedocs.io/en/latest/).

Pipenv memelihara dua file: 
+ `Pipfile`— File ini berisi berbagai jenis dependensi dan persyaratan.
+ `Pipfile.lock`— File ini berisi snapshot versi yang memungkinkan build deterministik.

Anda dapat membuat file-file ini di lingkungan pengembangan Anda dan memasukkannya ke dalam direktori tingkat atas bundel sumber yang Anda gunakan ke Elastic Beanstalk. Untuk informasi selengkapnya tentang dua file ini, lihat [Contoh Pipfile dan Pipfile.lock](https://pipenv.pypa.io/en/latest/basics/#).



Contoh berikut menggunakan Pipenv untuk menginstal Django dan kerangka kerja REST Django. Perintah ini membuat file `Pipfile` dan `Pipfile.lock`.

```
~/my-app$ pipenv install django
~/my-app$ pipenv install djangorestframework
```

 

## Precedence
<a name="python-configuration-requirements.precedence"></a>

Jika Anda menyertakan lebih dari satu file persyaratan yang dijelaskan dalam topik ini, Elastic Beanstalk hanya menggunakan salah satunya. Daftar berikut menunjukkan yang diutamakan, dalam urutan menurun.

1. `requirements.txt`

1. `Pipfile.lock`

1. `Pipfile`

**catatan**  
Dimulai dengan rilis platform Amazon Linux 2 7 Maret 2023, jika Anda menyediakan lebih dari satu file ini, Elastic Beanstalk akan mengeluarkan pesan konsol yang menyatakan salah satu file dependensi mana yang digunakan selama penerapan.

Langkah-langkah berikut menjelaskan logika yang diikuti Elastic Beanstalk untuk menginstal dependensi saat menerapkan instance.
+ Jika ada `requirements.txt` file, kami menggunakan perintah`pip install -r requirements.txt`.
+ Dimulai dengan rilis platform Amazon Linux 2 7 Maret 2023, jika tidak ada `requirements.txt` file, tetapi ada`Pipfile.lock`, kami menggunakan perintah`pipenv sync`. Sebelum rilis itu, kami menggunakan`pipenv install --ignore-pipfile`.
+ Jika tidak ada `requirements.txt` file atau a`Pipfile.lock`, tetapi ada`Pipfile`, kami menggunakan perintah`pipenv install --skip-lock`.
+ Jika tidak satu pun dari tiga file persyaratan ditemukan, kami tidak menginstal dependensi aplikasi apa pun.

# 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).

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

Tutorial ini memandu dalam deployment situs web [Django](https://www.djangoproject.com/) default yang dibuat otomatis ke lingkungan AWS Elastic Beanstalk yang menjalankan Python. Tutorial ini menunjukkan Anda cara meng-host sebuah aplikasi web Python di cloud dengan menggunakan lingkungan Elastic Beanstalk. 

Dalam tutorial ini, Anda akan melakukan hal berikut:
+ [Menyiapkan lingkungan virtual Python dan menginstal Django](#python-django-setup-venv)
+ [Buat proyek Django](#python-django-create-app)
+ [Konfigurasikan aplikasi Django Anda untuk Elastic Beanstalk](#python-django-configure-for-eb) 
+ [Men-deploy situs Anda dengan EB CLI](#python-django-deploy) 
+ [Perbarui aplikasi Anda](#python-django-update-app) 
+ [Bersihkan](#python-django-stopping)

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

Untuk mengikuti tutorial ini, Anda harus memiliki semua [Prasyarat Umum](python-development-environment.md) untuk Python yang diinstal, termasuk paket-paket berikut:
+ Python 3.7 atau yang lebih baru
+ `pip`
+ `virtualenv`
+ `awsebcli`

Kerangka kerja [Django](https://www.djangoproject.com/) akan diinstal sebagai bagian dari tutorial.

**catatan**  
Membuat lingkungan dengan EB CLI memerlukan [peran layanan](concepts-roles-service.md). Peran layanan dapat dibuat dengan membuat lingkungan di konsol Elastic Beanstalk. Jika Anda tidak memiliki peran layanan, EB CLI mencoba membuatnya saat Anda menjalankan `eb create`.

## Menyiapkan lingkungan virtual Python dan menginstal Django
<a name="python-django-setup-venv"></a>

Buat lingkungan virtual dengan `virtualenv` dan menggunakannya untuk menginstal Django dan dependensinya. Dengan menggunakan lingkungan virtual, Anda dapat mengetahui dengan tepat paket mana yang dibutuhkan aplikasi Anda, sehingga paket yang diperlukan diinstal pada EC2 instance Amazon yang menjalankan aplikasi Anda. 

Langkah-langkah berikut menunjukkan perintah yang harus Anda masukkan untuk Windows dan sistem berbasis Unix, yang ditampilkan pada tab terpisah.

**Untuk mempersiapkan lingkungan virtual Anda**

1. Buat dan aktifkan lingkungan virtual bernama `eb-virt`.

------
#### [ Unix-based systems ]

   ```
   ~$ virtualenv ~/eb-virt
   ```

------
#### [ Windows ]

   ```
   C:\> virtualenv %HOMEPATH%\eb-virt
   ```

------

1. Aktifkan lingkungan virtual.

------
#### [ Unix-based systems ]

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

------
#### [ Windows ]

   ```
   C:\>%HOMEPATH%\eb-virt\Scripts\activate
   (eb-virt) C:\>
   ```

------

   Anda akan melihat `(eb-virt)` ditambahkan ke prompt perintah Anda, yang menunjukkan bahwa Anda berada di lingkungan virtual.
**catatan**  
Prompt perintah Linux `~$` di direktori home Anda ditunjukkan hingga akhir dari instruksi ini. Di Windows ini`C:\Users\USERNAME>`, di *USERNAME* mana nama login Windows Anda.

1. Gunakan `pip` untuk menginstal Django.

   ```
   (eb-virt)~$ pip install django==2.2
   ```
**catatan**  
Versi Django yang Anda pasang harus kompatibel dengan versi Python pada konfigurasi Phyton Elastic Beanstalk yang Anda pilih untuk men-deploy aplikasi Anda. Untuk informasi tentang deployment, lihat [Men-deploy situs Anda dengan EB CLI](#python-django-deploy) dalam topik ini.  
Untuk informasi lebih lanjut tentang versi platform Python saat ini, lihat [Python](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python) di dokumen *Platform AWS Elastic Beanstalk *.  
Untuk kesesuaian versi Django dengan Python, lihat [Versi Python apa yang dapat saya gunakan dengan Django?](https://docs.djangoproject.com/en/3.1/faq/install/#what-python-version-can-i-use-with-django)

1. Untuk memverifikasi bahwa Django terpasang, masukkan berikut ini.

   ```
   (eb-virt)~$ pip freeze
   Django==2.2
   ...
   ```

   Perintah ini mencantumkan semua paket yang diinstal di lingkungan virtual Anda. Kemudian, Anda menggunakan output dari perintah ini untuk mengonfigurasi proyek Anda untuk digunakan dengan Elastic Beanstalk.

## Buat proyek Django
<a name="python-django-create-app"></a>

Sekarang Anda siap untuk membuat proyek Django dan menjalankannya pada mesin Anda, menggunakan lingkungan virtual.

**catatan**  
Tutorial ini menggunakan SQLite, yang merupakan mesin database yang disertakan dalam Python. Basis data di-deploy dengan file proyek Anda. Untuk lingkungan produksi, kami sarankan Anda menggunakan Amazon Relational Database Service (Amazon RDS), dan memisahkannya dari lingkungan Anda. Untuk informasi selengkapnya, lihat [Menambahkan instans Amazon RDS DB ke lingkungan Python Elastic Beanstalk Anda](create-deploy-python-rds.md).

**Untuk menghasilkan aplikasi Django**

1. Aktifkan lingkungan virtual Anda.

------
#### [ Unix-based systems ]

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

------
#### [ Windows ]

   ```
   C:\>%HOMEPATH%\eb-virt\Scripts\activate
   (eb-virt) C:\>
   ```

------

   Anda akan melihat prefiks `(eb-virt)` ditambahkan ke prompt perintah Anda, yang menunjukkan bahwa Anda berada di lingkungan virtual.
**catatan**  
Prompt perintah Linux `~$` di direktori home Anda dan direktori home Linux `~/` ditunjukkan hingga akhir instruksi ini. Di Windows ini`C:\Users\USERNAME>`, di *USERNAME* mana nama login Windows Anda.

1. Gunakan perintah `django-admin startproject` untuk membuat proyek Django bernama `ebdjango`.

   ```
   (eb-virt)~$ django-admin startproject ebdjango
   ```

   Perintah ini membuat sebuah situs Django standar bernama **ebdjango** dengan struktur direktori berikut.

   ```
   ~/ebdjango
     |-- ebdjango
     |   |-- __init__.py
     |   |-- settings.py
     |   |-- urls.py
     |   `-- wsgi.py
     `-- manage.py
   ```

1. Jalankan situs Django Anda secara lokal dengan `manage.py runserver`.

   ```
   (eb-virt) ~$ cd ebdjango
   ```

   ```
   (eb-virt) ~/ebdjango$ python manage.py runserver
   ```

1. Di peramban web, buka `http://127.0.0.1:8000/` untuk melihat situs.

1. Periksa log server untuk melihat output dari permintaan Anda. Untuk menghentikan server web dan kembali ke lingkungan virtual Anda, tekan **Ctrl\$1C**.

   ```
   Django version 2.2, using settings 'ebdjango.settings'
   Starting development server at http://127.0.0.1:8000/
   Quit the server with CONTROL-C.
   [07/Sep/2018 20:14:09] "GET / HTTP/1.1" 200 16348
   Ctrl+C
   ```

## Konfigurasikan aplikasi Django Anda untuk Elastic Beanstalk
<a name="python-django-configure-for-eb"></a>

Sekarang setelah Anda memiliki situs bertenaga Django pada mesin lokal Anda, Anda dapat mengonfigurasi untuk deployment dengan Elastic Beanstalk.

Secara default, Elastic Beanstalk mencari file bernama `application.py` untuk memulai aplikasi Anda. Karena ini tidak ada di proyek Django yang Anda buat, Anda perlu membuat beberapa penyesuaian pada lingkungan aplikasi Anda. Anda juga harus mengatur variabel lingkungan sehingga modul aplikasi Anda dapat dimuat.

**Mengonfigurasi situs Anda untuk Elastic Beanstalk**

1. Aktifkan lingkungan virtual Anda.

------
#### [ Unix-based systems ]

   ```
   ~/ebdjango$ source ~/eb-virt/bin/activate
   ```

------
#### [ Windows ]

   ```
   C:\Users\USERNAME\ebdjango>%HOMEPATH%\eb-virt\Scripts\activate
   ```

------

1. Jalankan `pip freeze`, kemudian simpan output ke file bernama `requirements.txt`.

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

   Elastic `requirements.txt` Beanstalk digunakan untuk menentukan paket mana yang akan diinstal EC2 pada instance yang menjalankan aplikasi Anda.

1. Membuat sebuah direktori bernama `.ebextensions`.

   ```
   (eb-virt) ~/ebdjango$ mkdir .ebextensions
   ```

1. Di direktori `.ebextensions`, tambahkan [file konfigurasi](ebextensions.md) bernama `django.config` dengan teks berikut.  
**Example \$1/ebdjango/.ebextensions/django.config**  

   ```
   option_settings:
     aws:elasticbeanstalk:container:python:
       WSGIPath: ebdjango.wsgi:application
   ```

   Pengaturan ini, `WSGIPath`, menentukan lokasi script WSGI yang digunakan Elastic Beanstalk untuk memulai aplikasi Anda.
**catatan**  
Jika Anda menggunakan versi platform Python Amazon Linux AMI (Amazon Linux 2 yang terdahulu), ganti nilai `WSGIPath` dengan `ebdjango/wsgi.py`. Nilai dalam contoh berfungsi dengan menggunakan server Gunicorn WSGI, yang tidak didukung pada versi platform Amazon Linux AMI.

1. Nonaktifkan lingkungan virtual Anda dengan perintah `deactivate`.

   ```
   (eb-virt) ~/ebdjango$ deactivate
   ```

   Aktifkan kembali lingkungan virtual setiap kali Anda perlu menambahkan paket ke aplikasi Anda atau menjalankan aplikasi secara lokal.

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

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

```
~/ebdjango/
|-- .ebextensions
|   `-- django.config
|-- ebdjango
|   |-- __init__.py
|   |-- settings.py
|   |-- urls.py
|   `-- wsgi.py
|-- db.sqlite3
|-- manage.py
`-- requirements.txt
```

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

Segera setelah deployment, Anda akan mengedit konfigurasi Django untuk menambahkan nama domain yang ditetapkan Elastic Beanstalk untuk aplikasi Anda ke `ALLOWED_HOSTS` Django. Kemudian Anda akan men-deploy kembali aplikasi Anda. Ini adalah persyaratan keamanan Django, dirancang untuk mencegah serangan header `Host` HTTP. Untuk informasi lebih lanjut, lihat [Validasi header host](https://docs.djangoproject.com/en/2.2/topics/security/#host-headers-virtual-hosting).

**Untuk membuat lingkungan dan men-deploy aplikasi Django Anda**
**catatan**  
Tutorial ini menggunakan EB CLI sebagai mekanisme deployment, tetapi Anda juga dapat menggunakan konsol Elastic Beanstalk untuk men-deploy file .zip yang berisi konten proyek Anda. 

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

   ```
   ~/ebdjango$ eb init -p python-3.7 django-tutorial
   Application django-tutorial has been created.
   ```

   Perintah ini membuat aplikasi bernama `django-tutorial`. Ini juga mengkonfigurasi repositori lokal Anda untuk membuat lingkungan dengan versi platform Python 3.7 terbaru.

1. (Opsional) Jalankan **eb init** lagi untuk mengonfigurasi key pair default sehingga Anda dapat menggunakan SSH untuk terhubung ke EC2 instance yang menjalankan aplikasi Anda.

   ```
   ~/ebdjango$ 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 membuatnya. Jika Anda tidak melihat prompt atau perlu mengubah pengaturan Anda nanti, jalankan **eb init -i**.

1. Membuat lingkungan dan men-deploy aplikasi Anda ke sana dengan **eb create**.

   ```
   ~/ebdjango$ eb create django-env
   ```
**catatan**  
Jika Anda melihat pesan kesalahan "peran layanan diperlukan", jalankan `eb create` secara interaktif (tanpa menentukan nama lingkungan) dan EB CLI membuat peran untuk Anda.

   Perintah ini membuat lingkungan Elastic Beanstalk dengan beban seimbang bernama `django-env`. Membuat lingkungan membutuhkan waktu sekitar 5 menit. Saat Elastic Beanstalk membuat sumber daya yang diperlukan untuk menjalankan aplikasi Anda, Elastic Beanstalk mengeluarkan pesan informasi yang disampaikan EB CLI ke terminal Anda.

1. Ketika proses pembuatan lingkungan selesai, temukan nama domain lingkungan baru Anda dengan menjalankan **eb status**.

   ```
   ~/ebdjango$ eb status
   Environment details for: django-env
     Application name: django-tutorial
     ...
     CNAME: eb-django-app-dev.elasticbeanstalk.com
     ...
   ```

   Nama domain lingkungan Anda adalah nilai dari properti `CNAME`.

1. Buka file `settings.py` dalam direktori `ebdjango`. Temukan pengaturan `ALLOWED_HOSTS`, dan kemudian tambahkan nama domain aplikasi yang Anda temukan di langkah sebelumnya ke nilai pengaturan. Jika Anda tidak dapat menemukan pengaturan ini dalam file, tambahkan itu ke baris baru.

   ```
   ...
   ALLOWED_HOSTS = ['eb-django-app-dev.elasticbeanstalk.com']
   ```

1. Simpan file, dan kemudian deploy aplikasi Anda dengan menjalankan **eb deploy**. Ketika Anda menjalankan **eb deploy**, EB CLI memaketkan konten direktori proyek Anda dan men-deploy ke lingkungan Anda.

   ```
   ~/ebdjango$ eb deploy
   ```
**catatan**  
Jika Anda menggunakan Git dengan proyek Anda, lihat [Menggunakan EB CLI dengan Git](eb3-cli-git.md).

1. Ketika proses pembaruan lingkungan selesai, buka situs web Anda dengan **eb open**.

   ```
   ~/ebdjango$ eb open
   ```

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

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 Django pertama Anda dengan Elastic Beanstalk\$1

## Perbarui aplikasi Anda
<a name="python-django-update-app"></a>

Sekarang setelah menjalankan aplikasi Elastic Beanstalk, Anda dapat memperbarui dan men-deploy kembali aplikasi Anda atau konfigurasinya, dan Elastic Beanstalk melakukan pekerjaan memperbarui instans dan memulai versi aplikasi baru Anda.

Untuk contoh ini, kita akan mengaktifkan konsol admin Django dan mengonfigurasi beberapa pengaturan lain.

### Mengubah pengaturan situs Anda
<a name="python-django-modify-site"></a>

Secara default, situs web Django Anda menggunakan zona waktu UTC untuk menampilkan waktu. Anda dapat mengubah ini dengan menentukan zona waktu di `settings.py`.

**Untuk mengubah zona waktu situs Anda**

1. Modifikasi pengaturan `TIME_ZONE` dalam `settings.py`.  
**Example \$1/ .py ebdjango/ebdjango/settings**  

   ```
   ...
   # Internationalization
   LANGUAGE_CODE = 'en-us'
   TIME_ZONE = 'US/Pacific'
   USE_I18N = True
   USE_L10N = True
   USE_TZ = True
   ```

   Untuk daftar zona waktu, kunjungi [halaman ini](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones).

1. Men-deploy aplikasi ke lingkungan Elastic Beanstalk Anda.

   ```
   ~/ebdjango/$ eb deploy
   ```

### Membuat administrator situs
<a name="python-django-create-admin"></a>

Anda dapat membuat administrator situs untuk aplikasi Django Anda untuk mengakses konsol admin langsung dari situs web. Detail login administrator disimpan dengan aman di citra basis data lokal yang disertakan dalam proyek default yang dihasilkan Django.

**Untuk membuat administrator situs**

1. Inisialisasi basis data lokal aplikasi Django Anda.

   ```
   (eb-virt) ~/ebdjango$ python manage.py migrate
   Operations to perform:
     Apply all migrations: admin, auth, contenttypes, sessions
   Running migrations:
     Applying contenttypes.0001_initial... OK
     Applying auth.0001_initial... OK
     Applying admin.0001_initial... OK
     Applying admin.0002_logentry_remove_auto_add... OK
     Applying admin.0003_logentry_add_action_flag_choices... OK
     Applying contenttypes.0002_remove_content_type_name... OK
     Applying auth.0002_alter_permission_name_max_length... OK
     Applying auth.0003_alter_user_email_max_length... OK
     Applying auth.0004_alter_user_username_opts... OK
     Applying auth.0005_alter_user_last_login_null... OK
     Applying auth.0006_require_contenttypes_0002... OK
     Applying auth.0007_alter_validators_add_error_messages... OK
     Applying auth.0008_alter_user_username_max_length... OK
     Applying auth.0009_alter_user_last_name_max_length... OK
     Applying sessions.0001_initial... OK
   ```

1. Jalankan `manage.py createsuperuser` untuk membuat administrator.

   ```
   (eb-virt) ~/ebdjango$ python manage.py createsuperuser
   Username: admin
   Email address: me@mydomain.com
   Password: ********
   Password (again): ********
   Superuser created successfully.
   ```

1. Untuk memberitahu Django tempat menyimpan file statis, tentukan `STATIC_ROOT` dalam `settings.py`.  
**Example \$1/ .py ebdjango/ebdjango/settings**  

   ```
   # Static files (CSS, JavaScript, Images)
   # https://docs.djangoproject.com/en/2.2/howto/static-files/
   STATIC_URL = '/static/'
   STATIC_ROOT = 'static'
   ```

1. Jalankan `manage.py collectstatic` untuk mengisi `static` direktori dengan aset statis (JavaScript, CSS, dan gambar) untuk situs admin.

   ```
   (eb-virt) ~/ebdjango$ python manage.py collectstatic
   119 static files copied to ~/ebdjango/static
   ```

1. Men-deploy aplikasi Anda.

   ```
   ~/ebdjango$ eb deploy
   ```

1. Lihat konsol admin dengan membuka situs di peramban Anda, tambahkan `/admin/` ke URL situs, seperti berikut ini.

   ```
   http://djang-env.p33kq46sfh.us-west-2.elasticbeanstalk.com/admin/
   ```  
![\[Masukkan nama pengguna dan kata sandi yang Anda buat pada langkah 2 untuk masuk ke konsol admin.\]](http://docs.aws.amazon.com/id_id/elasticbeanstalk/latest/dg/images/eb_django_admin_login.png)

1. Masuk dengan nama pengguna dan kata sandi yang Anda konfigurasikan pada langkah 2.  
![\[Konsol administrasi Django untuk situs web Django Anda di-deploy dengan Elastic Beanstalk\]](http://docs.aws.amazon.com/id_id/elasticbeanstalk/latest/dg/images/eb_django_admin_console.png)

Anda dapat menggunakan prosedur lokal yang serupa updating/testing diikuti oleh**eb deploy**. Elastic Beanstalk melakukan pekerjaan pembaruan server langsung Anda, sehingga Anda dapat fokus pada pengembangan aplikasi bukan administrasi server\$1

### Menambahkan file konfigurasi migrasi basis data
<a name="python-django-migrate-site"></a>

Anda dapat menambahkan perintah ke skrip `.ebextensions` yang dijalankan saat situs Anda diperbarui. Hal ini memungkinkan Anda untuk menghasilkan migrasi basis data secara otomatis.

**Untuk menambahkan langkah migrasi saat aplikasi Anda di-deploy**

1. Buat [file lonfigurasi](ebextensions.md) bernama `db-migrate.config` dengan konten berikut.  
**Example \$1/ebdjango/.ebextensions/db-migrate.config**  

   ```
   container_commands:
     01_migrate:
       command: "source /var/app/venv/*/bin/activate && python3 manage.py migrate"
       leader_only: true
   option_settings:
     aws:elasticbeanstalk:application:environment:
       DJANGO_SETTINGS_MODULE: ebdjango.settings
   ```

   File konfigurasi ini mengaktifkan lingkungan virtual server dan menjalankan `manage.py migrate` perintah selama proses penyebaran, sebelum memulai aplikasi Anda. Karena berjalan sebelum aplikasi dimulai, Anda juga harus mengonfigurasi variabel lingkungan `DJANGO_SETTINGS_MODULE` secara eksplisit (biasanya `wsgi.py` akan mengurus hal ini untuk Anda selama startup). Menentukan `leader_only: true` dalam perintah akan memastikan bahwa itu hanya akan dijalankan sekali ketika Anda men-deploy ke beberapa instans.

1. Men-deploy aplikasi Anda.

   ```
   ~/ebdjango$ eb deploy
   ```

## Bersihkan
<a name="python-django-stopping"></a>

Untuk menghemat jam instans dan AWS sumber daya lainnya di antara sesi pengembangan, hentikan lingkungan Elastic Beanstalk Anda dengan. **eb terminate**

```
~/ebdjango$ eb terminate django-env
```

Perintah ini mengakhiri lingkungan dan semua sumber AWS daya yang berjalan di dalamnya. Perintah tersebut bagaimana pun juga tidak akan menghapus aplikasi, sehingga Anda selalu dapat membuat lebih banyak lingkungan dengan konfigurasi yang sama dengan menjalankan **eb create** lagi.

Jika Anda telah selesai dengan aplikasi sampel, Anda juga dapat menghapus folder proyek dan lingkungan virtual.

```
~$ rm -rf ~/eb-virt
~$ rm -rf ~/ebdjango
```

## Langkah selanjutnya
<a name="python-django-next-steps"></a>

Untuk informasi selengkapnya tentang Django, termasuk tutorial secara mendalam, lihat [Dokumentasi resmi](https://docs.djangoproject.com/en/2.2/).

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

# Menambahkan instans Amazon RDS DB ke lingkungan Python Elastic Beanstalk Anda
<a name="create-deploy-python-rds"></a>

Topik ini memberikan instruksi untuk membuat Amazon RDS menggunakan konsol Elastic Beanstalk. Anda dapat menggunakan instans DB Amazon Relational Database Service (Amazon RDS) untuk menyimpan data yang dikumpulkan dan dimodifikasi oleh aplikasi Anda. Basis data dapat digabungkan ke lingkungan Anda dan dikelola oleh Elastic Beanstalk, atau dapat dibuat sebagai dipisahkan dan dikelola secara eksternal oleh layanan lain. Dalam instruksi ini database digabungkan dengan lingkungan Anda dan dikelola oleh Elastic Beanstalk. Untuk informasi lebih lanjut tentang mengintegrasikan Amazon RDS dengan Elastic Beanstalk, lihat. [Menambahkan basis data ke lingkungan Elastic Beanstalk Anda](using-features.managing.db.md)

**Topics**
+ [Menambahkan instans DB ke lingkungan Anda](#python-rds-create)
+ [Mengunduh driver](#python-rds-drivers)
+ [Menghubungkan ke basis data](#python-rds-connect)

## Menambahkan instans DB ke lingkungan Anda
<a name="python-rds-create"></a>

**Untuk menambahkan instans DB ke lingkungan Anda**

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. Pada panel navigasi, pilih **Konfigurasi**.

1. Di kategori konfigurasi **Basis data**, pilih **Edit**.

1. Pilih mesin DB, dan masukkan nama pengguna dan kata sandi.

1. Untuk menyimpan perubahan pilih **Terapkan** di bagian bawah halaman.

Menambahkan instans DB memakan waktu sekitar 10 menit. Ketika pembaruan lingkungan selesai, nama host instans DB dan informasi koneksi lainnya tersedia untuk aplikasi Anda melalui properti lingkungan berikut:


| Nama properti | Deskripsi | Nilai properti | 
| --- | --- | --- | 
|  `RDS_HOSTNAME`  |  Nama host instans DB.  |  Di tab **Konektivitas & keamanan** di konsol Amazon RDS: **Titik akhir**.  | 
|  `RDS_PORT`  |  Port tempat instans DB menerima koneksi. Nilai default bervariasi di antara mesin DB.  |  Di tab **Konektivitas & keamanan** di konsol Amazon RDS: **Port**.  | 
|  `RDS_DB_NAME`  |  Nama basis data, **ebdb**.  |  Di tab **Konfigurasi** di konsol Amazon RDS: **Nama DB**.  | 
|  `RDS_USERNAME`  |  Nama pengguna yang Anda konfigurasi untuk basis data Anda.  |  Di tab **Konfigurasi** di konsol Amazon RDS: **Nama pengguna utama**.  | 
|  `RDS_PASSWORD`  |  Kata sandi yang Anda konfigurasi untuk basis data Anda.  |  Tidak tersedia untuk referensi di konsol Amazon RDS.  | 

Untuk informasi selengkapnya tentang mengonfigurasi instance database yang digabungkan dengan lingkungan Elastic Beanstalk, lihat. [Menambahkan basis data ke lingkungan Elastic Beanstalk Anda](using-features.managing.db.md)

## Mengunduh driver
<a name="python-rds-drivers"></a>

Menambahkan driver basis data ke [file persyaratan](python-configuration-requirements.md) proyek Anda.

**Example requirements.txt – Django dengan MySQL**  

```
Django==2.2
mysqlclient==2.0.3
```

**Paket driver umum untuk Python**
+ **MySQL** – `mysqlclient`
+ **PostgreSQL** – `psycopg2`
+ **Oracle** – `cx_Oracle`
+ **SQL Server** – `adodbapi`

Untuk informasi selengkapnya lihat [Python DatabaseInterfaces](https://wiki.python.org/moin/DatabaseInterfaces) dan [Django 2.2 -](https://docs.djangoproject.com/en/2.2/ref/databases) basis data yang didukung.

## Menghubungkan ke basis data
<a name="python-rds-connect"></a>

Elastic Beanstalk memberikan informasi koneksi untuk instans DB terlampir di properti lingkungan. Gunakan `os.environ['VARIABLE']` untuk membaca properti dan mengonfigurasi koneksi basis data.

**Example File pengaturan Django – kamus BASIS DATA**  

```
import os

if 'RDS_HOSTNAME' in os.environ:
    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.mysql',
            'NAME': os.environ['RDS_DB_NAME'],
            'USER': os.environ['RDS_USERNAME'],
            'PASSWORD': os.environ['RDS_PASSWORD'],
            'HOST': os.environ['RDS_HOSTNAME'],
            'PORT': os.environ['RDS_PORT'],
        }
    }
```

# Alat Python dan sumber daya
<a name="create-deploy-python-tools-resources"></a>

Ada beberapa tempat yang dapat dikunjungi untuk mendapatkan bantuan tambahan ketika mengembangkan aplikasi Python Anda:


****  

| Sumber Daya | Deskripsi | 
| --- | --- | 
| [AWS SDK untuk Python (Boto3) pada GitHub](https://github.com/boto/boto3) | Instal Boto3 bersumber dari. GitHub | 
| [AWS SDK untuk Python (Boto3) beranda](https://aws.amazon.com//sdk-for-python/) |  AWS SDK untuk Python (Boto3) Beranda. | 
| [Pusat Pengembang Python](https://aws.amazon.com/python/) | Tempat yang lengkap mengakomodasikan segala kebutuhan Anda mulai dari kode sampel, dokumentasi, alat, dan sumber daya tambahan. |