Apa yang dimaksud dengan Kontainer dalam komputasi awan?

Sejak Docker hadir di tahun 2013, kontainer telah meledak popularitasnya. Banyak perusahaan telah mengintegrasikan kontainer ke dalam alur kerja mereka karena kontainer memungkinkan mereka untuk dengan mudah menyebarkan, mendistribusikan, mengelola, dan menskalakan perangkat lunak mereka.

Pada artikel ini, kami akan menjelaskan apa itu kontainer dalam komputasi awan. Kita akan membahas tentang manfaat menggunakan kontainer, kasus penggunaannya, membandingkannya dengan mesin virtual, dan melihat Docker dan Kubernetes. Terakhir, kami akan mengajarkan Anda cara membuat kode, mendokumentasi, dan men-deploy aplikasi web ke Back4app Containers – gratis!

Definisi Wadah

Kontainer adalah paket yang dapat dieksekusi secara mandiri yang mencakup semua yang diperlukan untuk menjalankan aplikasi: kode, runtime, pustaka, variabel lingkungan, dan file konfigurasi. Hal yang mengagumkan tentang aplikasi dalam kontainer adalah aplikasi tersebut dapat berjalan di mana saja, mulai dari lingkungan pengembangan lokal hingga cloud publik dan sebagainya. Kontainer berukuran kecil, efisien, dan memungkinkan isolasi yang efektif.

Manfaat menggunakan Wadah

Menggunakan kontainer memiliki beberapa manfaat. Mari kita lihat beberapa di antaranya.

Efisiensi

Kontainer membutuhkan sumber daya sistem yang lebih sedikit daripada server tradisional atau VM karena tidak menyertakan image sistem operasi. Hal ini membuatnya sangat efisien, ukurannya kecil (biasanya diukur dalam MB) dan memungkinkan Anda untuk menjalankan sejumlah besar aplikasi pada satu server.

Isolasi Aplikasi

Kontainer mengisolasi aplikasi dan ketergantungannya dari sistem host. Pada saat yang sama, kontainer dapat berbagi kernel OS dan sumber daya sistem seperti CPU, memori, penyimpanan, dan jaringan.

Portabilitas

Perangkat lunak dalam container dapat berjalan dan berperilaku dengan cara yang sama di hampir semua mesin yang memiliki mesin container yang terinstal. Hal ini memudahkan penerapan dan pemindahan aplikasi di antara lingkungan yang berbeda serta menghilangkan masalah “ini berfungsi di mesin saya”.

Pemisahan Tanggung Jawab

Kontainer memungkinkan pemisahan tanggung jawab dengan membagi tugas dan tanggung jawab antara pengembang dan tim operasi TI. Pengembang bertanggung jawab untuk membuat dan memelihara kode aplikasi dan ketergantungan, sementara tim operasi TI fokus pada penerapan dan pengelolaan kontainer dan infrastruktur yang mendasarinya.

Pengembangan Aplikasi Lebih Cepat

Kontainerisasi mempermudah pengembangan, pengujian, pengelolaan, dan distribusi perangkat lunak. Kontainer dapat dengan mudah diintegrasikan dengan sistem CI/CD, yang dapat sangat mempercepat proses pengembangan dan pengiriman perangkat lunak.

Penskalaan Mudah

Aplikasi yang dikontainerisasi yang dikombinasikan dengan platform orkestrasi seperti Kubernetes dapat dengan mudah ditingkatkan sesuai permintaan. Hal ini memungkinkan bisnis Anda mengakomodasi beban kerja yang tinggi sekaligus meminimalkan biaya.

Kasus Penggunaan Wadah

Teknologi kontainer memiliki banyak kasus penggunaan untuk pengembang serta tim operasi TI.

Pengembangan Kontainer-Asli

Pengembangan container-native adalah pendekatan pengembangan perangkat lunak yang memanfaatkan kontainer sebagai blok bangunan utama. Dalam pengembangan container-native, aplikasi dikemas sebagai kontainer dan dijalankan dalam lingkungan terkontainerisasi. Pendekatan pengembangan ini memberi Anda semua fasilitas keren yang ditawarkan kontainer.

Integrasi Berkelanjutan dan Pengiriman Berkelanjutan (CI/CD)

Dalam pipeline CI/CD, kontainer digunakan untuk mengemas aplikasi dan menjalankan pengujian otomatis, sehingga memungkinkan untuk menguji dan menerapkan aplikasi dengan cara yang konsisten dan berulang. Container dapat dengan mudah dibuat, diuji, dan digunakan sebagai bagian dari pipeline CI/CD, sehingga mengurangi risiko kesalahan dan meningkatkan efisiensi proses pengembangan perangkat lunak secara keseluruhan.

Layanan Mikro

Kontainer dapat digunakan untuk mengembangkan aplikasi yang mengikuti arsitektur layanan mikro. Dengan kontainer, Anda dapat dengan mudah membagi aplikasi monolitik Anda menjadi kumpulan layanan berbutir halus yang digabungkan secara longgar yang berjalan di dalam kontainer yang berbeda.

Lingkungan Pengembangan

Kontainer memudahkan tim pengembang untuk menyiapkan lingkungan pengembangan mereka dengan cepat. Mereka menyediakan lingkungan pengembangan yang konsisten terlepas dari sistem operasi host dan pustaka host.

Proses Batch

Proses batch dapat dengan mudah di-container-kan dan disebarkan ke cloud. Setiap tugas dikemas sebagai gambar kontainer individual dan dijalankan sebagai instance kontainer terpisah. Hal ini memungkinkan pemanfaatan sumber daya yang efisien, karena setiap tugas berjalan di lingkungannya sendiri dan tidak mengganggu tugas lainnya.

Kontainer vs Mesin Virtual

Kontainer dan mesin virtual adalah dua pendekatan yang berbeda untuk virtualisasi. Meskipun keduanya memiliki beberapa kesamaan, namun keduanya sangat berbeda.

Mesin virtual (VM) adalah abstraksi dari perangkat keras fisik. Mesin ini memungkinkan kita mengubah satu server menjadi beberapa server. Masing-masing VM memiliki sistem operasinya sendiri dan biasanya dikelola oleh hypervisor. VM cocok untuk menjalankan banyak aplikasi (pada server yang sama), aplikasi monolitik, dan aplikasi yang membutuhkan tingkat isolasi dan keamanan yang tinggi. Kekurangannya adalah cenderung memakan banyak ruang dan bisa jadi cukup lambat untuk booting.

Di sisi lain, kontainer tervirtualisasi pada tingkat sistem operasi. Container menggunakan lebih sedikit ruang karena menggunakan kernel Linux yang sama, lebih efisien, booting lebih cepat, sangat skalabel, dan dapat menangani lebih banyak aplikasi. Kontainer dikelola oleh Mesin Kontainer. Kasus penggunaan utamanya berbeda dengan VM adalah layanan mikro dan aplikasi yang harus portabel, ringan, dan dapat diskalakan.

Anda juga dapat menggabungkan kontainer dan VM untuk mendapatkan manfaat dari keduanya.

Docker dan Kubernetes

Dua alat yang paling populer untuk bekerja dengan kontainer adalah Docker dan Kubernetes. Mari kita jelaskan cara kerja keduanya dan melihat perbedaannya.

Docker adalah proyek sumber terbuka berbasis Linux yang digunakan untuk mengotomatiskan penyebaran dan pengelolaan aplikasi dalam kontainer ringan. Hal ini memungkinkan aplikasi yang dikontainerisasi bekerja secara efisien di lingkungan yang berbeda. Saat ini Docker dapat ditemukan hampir di mana saja, mulai dari mesin Linux hingga penyedia layanan cloud yang besar, dan seterusnya.

Alternatif Docker yang paling populer adalah Podman, LXD, dan containerd.

Kubernetes (K8s) adalah sistem orkestrasi kontainer sumber terbuka untuk mengotomatiskan penerapan, penskalaan, dan pengelolaan aplikasi dalam kontainer. Sejak dirilis pada tahun 2014, Kubernetes telah menjadi standar de facto untuk menerapkan dan mengoperasikan aplikasi dalam kontainer di lingkungan cloud. Manfaat Kubernetes meliputi skalabilitas, ketersediaan tinggi, operasi otomatis, abstraksi infrastruktur, dan pemantauan kesehatan.

Platform orkestrasi lainnya termasuk: AWS ECS, Nomad, dan Red Hat OpenShift.

Jadi, apa perbedaan antara Docker dan Kubernetes? Secara sederhana, Docker memungkinkan kita mengemas dan mendistribusikan aplikasi di dalam kontainer, sedangkan Kubernetes memudahkan beberapa kontainer untuk bekerja selaras satu sama lain.

Mengembangkan Aplikasi dengan menggunakan Arsitektur berbasis Container

Di bagian tutorial ini, kita akan membuat, mendokumentasi, dan menggunakan REST API sederhana ke Back4app Containers.

Apa yang dimaksud dengan Back4app Containers?

Back4app Containers adalah platform open-source gratis untuk menyebarkan dan menskalakan aplikasi pada kontainer yang didistribusikan secara global dalam infrastruktur cloud.

Ini memungkinkan Anda untuk fokus pada perangkat lunak Anda dan mengirimkannya lebih cepat tanpa perlu khawatir tentang DevOps. Platform ini terintegrasi erat dengan GitHub, memiliki sistem CI/CD bawaan, dan memungkinkan Anda untuk menyiapkan dan menjalankan aplikasi dalam hitungan menit!

Mengapa menggunakan Back4app Containers?

• Terintegrasi dengan baik dengan GitHub
• Penerapan tanpa waktu henti
• Mudah digunakan & memiliki tingkat gratis
• Dukungan pelanggan yang sangat baik

Pengenalan Proyek

Kami akan membangun API REST sederhana yang akan berfungsi sebagai daftar pantauan film. Aplikasi web akan memungkinkan operasi CRUD dasar seperti menambahkan film, menghapus film, dan sebagainya. Untuk membuat API, kita akan menggunakan framework Flask. Terakhir, kita akan melakukan Dockerisasi proyek dan mendemonstrasikan betapa mudahnya menerapkannya ke Back4app Container.

Prasyarat

• Pengalaman dengan kerangka kerja Flask
• Pemahaman dasar tentang Docker dan kontainer
• Kemampuan untuk menggunakan Git dan GitHub

Aplikasi Kode

Langkah-langkah berikut ini mengharuskan Anda untuk menginstal Python. Jika Anda belum menginstal Python, silakan unduh.

Inisialisasi proyek

Pertama, buat direktori khusus untuk aplikasi Anda dan arahkan ke sana:

$ mkdir flask-watchlist
$ cd flask-watchlist

Berikutnya, ciptakan lingkungan virtual baru dan aktifkan:

$ python3 -m venv venv && source venv/bin/activate

Karena kita akan menggunakan Flask sebagai kerangka kerja, kita harus menginstalnya:

$ (venv) pip install Flask==2.2.2

Buat app.py dengan konten berikut:

# app.py

from flask import Flask

app = Flask(__name__)
app.config['JSON_SORT_KEYS'] = False


@app.route('/')
def index_view():
    return {
        'detail': 'Hello world!'
    }

Kode ini menginisialisasi Flask dan membuat titik akhir sederhana yang mengembalikan sebuah pesan.

Jalankan server dengan:

$ flask run

Buka http://localhost:5000/ dan Anda akan melihat pesan yang bertuliskan Hello world!.

Basis data

Untuk basis data, kita akan menggunakan SQLite. SQLite adalah sistem manajemen basis data relasional yang tertanam dan tidak memerlukan server. Untuk menyederhanakan bekerja dengan database, kita akan menginstal Flask-SQLAlchemy – sebuah ekstensi untuk Flask yang menambahkan dukungan untuk SQLAlchemy ke aplikasi Anda.

Lanjutkan dan instal dengan menjalankannya:

$ (venv) pip install Flask-SQLAlchemy==3.0.3

Selanjutnya, arahkan ke bagian atas app.py dan ubahlah seperti ini untuk menginisialisasi basis data:

# app.py

db = SQLAlchemy()
app = Flask(__name__)
app.config['JSON_SORT_KEYS'] = False
app.config['SECRET_KEY'] = '5b3cd5b80eb8b217c20fb37074ff4a33'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///default.db"
db.init_app(app)

Jangan lupakan impornya:

from flask_sqlalchemy import SQLAlchemy

Selanjutnya, mari kita tentukan model basis data kita.

Karena kita membuat aplikasi daftar pantauan film sederhana, kita hanya memerlukan satu model. Tentukan model Film seperti ini:

# app.py

class Movie(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(128), nullable=False)
    release_date = db.Column(db.Date(), nullable=False)

    is_watched = db.Column(db.Boolean, default=False)
    watched_at = db.Column(db.DateTime, default=None, nullable=True)

    def as_dict(self):
        return {c.name: getattr(self, c.name) for c in self.__table__.columns}

    def __repr__(self):
        return '<Movie %r>' % self.title

Untuk menginisialisasi dan mengisi basis data kita, kita akan membuat skrip Python sederhana. Navigasikan ke root proyek Anda dan buat sebuah berkas baru bernama init_db.py dengan isi sebagai berikut:

# init_db.py

from datetime import date

from app import db, app
from app import Movie

with app.app_context():
    db.create_all()

    if Movie.query.count() == 0:
        movies = [
            Movie(title='Fight Club', release_date=date(1999, 9, 15)),
            Movie(title='The Matrix', release_date=date(1999, 3, 31)),
            Movie(title='Donnie Darko', release_date=date(2001, 1, 19)),
            Movie(title='Inception', release_date=date(2010, 7, 16)),
        ]

        for movie in movies:
            db.session.add(movie)

        db.session.commit()

Hal terakhir yang harus kita lakukan adalah menjalankan skrip:

$ (venv) python init_db.py

Ini akan membuat basis data, tabel basis data, dan mengisinya. File database akan ditempatkan di folder contoh.

Titik akhir API

Aplikasi web kami akan memiliki titik akhir sebagai berikut:

1. / mengembalikan informasi API dasar
2. /api/ mengembalikan daftar film
3. /api/create/ menambahkan film baru ke daftar pantauan
4. /api/ / mengembalikan rincian film tertentu
5. /api/watch/ / menandai film seperti yang dilihat

Lanjutkan dan tentukan titik akhir di bagian bawah app.py:

# app.py

@app.route('/')
def index_view():
    return {
        'name': 'flask-watchlist',
        'description': 'a simple app for tracking the movies you want to watch',
        'version': 1.1,
    }


@app.route('/api/')
def list_view():
    json = [movie.as_dict() for movie in Movie.query.all()]
    return jsonify(json)


@app.route('/api/<int:movie_id>/', methods=['GET', 'DELETE'])
def detail_view(movie_id):
    movie = db.get_or_404(Movie, movie_id)

    if request.method == 'DELETE':
        db.session.delete(movie)
        db.session.commit()

        return {
            'detail': 'Movie has been successfully deleted.'
        }
    else:
        return movie.as_dict()


@app.route('/api/create/', methods=['POST'])
def create_view():
    title = request.form.get('title')
    release_date = request.form.get('release_date', type=float)

    if title is None or release_date is None:
        return {
            'detail': 'Please provide the title and release_date.'
        }, 400

    movie = Movie(title=title, release_date=datetime.fromtimestamp(release_date))
    db.session.add(movie)
    db.session.commit()

    return movie.as_dict()


@app.route('/api/watch/<int:movie_id>/')
def watch_view(movie_id):
    movie = db.get_or_404(Movie, movie_id)

    if movie.is_watched:
        return {
            'detail': 'Movie has already been watched.'
        }, 400

    movie.is_watched = True
    movie.watched_at = datetime.now()
    db.session.commit()

    return movie.as_dict()

Jangan lupakan impornya:

from datetime import datetime
from flask import request, jsonify

Bagus, aplikasi kita sekarang kurang lebih sudah lengkap. Jalankan server pengembangan:

$ (venv) flask run

Menguji apakah Anda dapat mengambil daftar film:

$ (venv) curl http://localhost:5000/api/ | jq '.'

[
  {
    "id": 1,
    "title": "Fight Club",
    "release_date": "Wed, 15 Sep 1999 00:00:00 GMT",
    "is_watched": false,
    "watched_at": null
  },
  {
    "id": 2,
    "title": "The Matrix",
    "release_date": "Wed, 31 Mar 1999 00:00:00 GMT",
    "is_watched": false,
    "watched_at": null
  },
  ...
]

Gunicorn

Server pengembangan Flask tidak cocok untuk produksi, jadi mari kita ganti dengan Gunicorn. Gunicorn atau “Green Unicorn” adalah Server HTTP WSGI Python WSGI yang siap produksi untuk Unix.

Instal dengan menjalankannya:

$ (venv) pip install gunicorn==20.1.0

Setelah paket terinstal, Anda dapat memulai server WSGI Anda seperti ini:

$ (venv) gunicorn -w 2 -b 0.0.0.0:5000 app:app

[INFO] Starting gunicorn 20.1.0
[INFO] Listening at: http://0.0.0.0:5000 (1)
[INFO] Using worker: sync
[INFO] Booting worker with pid: 7
[INFO] Booting worker with pid: 8

Perlu diingat bahwa perintah ini hanya bekerja pada sistem operasi berbasis UNIX.

Ini akan memulai dua pekerja Gunicorn dan mengekspos aplikasi Anda ke internet. Untuk mengakses aplikasi, buka peramban web favorit Anda dan buka http://localhost:5000.

persyaratan.txt

Hal terakhir yang perlu kita lakukan sebelum mendokumentasi aplikasi kita adalah membuat berkas requirements.txt. File requirements.txt digunakan untuk menentukan dependensi proyek.

Cara termudah untuk menghasilkannya adalah dengan berlari:

$ (venv) pip freeze > requirements.txt

Aplikasi Dockerize

Langkah-langkah berikut ini mengharuskan Anda untuk menginstal Docker. Cara termudah untuk menginstal Docker adalah dengan mengunduh Docker Desktop.

Untuk memverifikasi bahwa Anda telah menginstal Docker, jalankan:

$ docker --version

Docker version 20.10.22, build 3a2c30b

Dockerfile

Untuk mendokumentasi aplikasi kita, kita akan menggunakan Dockerfile. Dockerfile adalah berkas teks biasa yang memungkinkan kita mendefinisikan citra dasar, lingkungan, variabel lingkungan, perintah, pengaturan jaringan, volume, dan sebagainya.

Buat berkas Docker di root proyek Anda dengan konten berikut:

# syntax=docker/dockerfile:1.4
FROM --platform=$BUILDPLATFORM python:3.10-alpine

# set the working directory
WORKDIR /app

# set environmental variables
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# install the requirements
COPY requirements.txt /app
RUN --mount=type=cache,target=/root/.cache/pip \
    pip3 install -r requirements.txt

# copy the code to the container
COPY . .

# initialize the database (create DB, tables, populate)
RUN python init_db.py

# expose
EXPOSE 5000/tcp

# entrypoint command
CMD ["gunicorn", "-w", "2", "-b", "0.0.0.0:5000", "app:app"]

1. Kami menggunakan python:3.10-alpine sebagai gambar dasar.
2. Mengatur PYTHONDONTWRITEBYTECODE ke 1 membuat Python tidak lagi menulis file .pyc ke disk.
3. Mengatur PYTHONUNBUFFERED ke 1 memastikan bahwa aliran keluaran Python dikirim langsung ke terminal.

Untuk informasi lebih lanjut tentang menulis Dockerfile, lihat referensi Dockerfile.

.dockerignore

Sebelum Docker membangun citra, ia akan mencari berkas .dockerignore. Berkas .dockerignore memungkinkan kita menentukan berkas mana yang tidak ingin disertakan dalam citra. Hal ini dapat sangat mengurangi ukuran gambar. Cara kerjanya mirip dengan file .gitignore.

Buat berkas .dockerignore di root proyek dengan konten berikut:

# .dockerignore

.git/
instance/
__pycache__/
.idea/

Pastikan untuk menambahkan direktori atau file tambahan yang ingin Anda kecualikan.

Membangun dan menjalankan gambar

Selanjutnya, mari kita membangun dan menandai citra Docker kita.

$ docker build -t flask-watchlist:1.0 .

[+] Building 11.1s (15/15) FINISHED
 => [internal] load build definition from Dockerfile                                                                                                                                                                                                                                                               0.0s 
 => => transferring dockerfile: 32B                                                                                                                                                                                                                                                                                0.0s 
 => [internal] load .dockerignore                                                                                                                                                                                                                                                                                  0.0s 
 => => transferring context: 34B                                                                                                                                                                                                                                                                                   0.0s 
 => resolve image config for docker.io/docker/dockerfile:1.4                                                                                                                                                                                                                                                       0.5s 
 => CACHED docker-image://docker.io/docker/dockerfile:1.4@sha256:9ba7531a0dbc                                                                                                                                                                                  0.0s 
 => [internal] load build definition from Dockerfile                                                                                                                                                                                                                                                               0.0s 
 => [internal] load .dockerignore                                                                                                                                                                                                                                                                                  0.0s 
 => [internal] load metadata for docker.io/library/python:3.10-alpine                                                                                                                                                                                                                                              0.5s 
 => [stage-0 1/6] FROM docker.io/library/python:3.10-alpine@sha256:da5ab5e911253dfb                                                                                                                                                                                0.0s 
 => [internal] load build context                                                                                                                                                                                                                                                                                  0.3s 
 => => transferring context: 182.45kB                                                                                                                                                                                                                                                                              0.2s 
 => CACHED [stage-0 2/6] WORKDIR /app                                                                                                                                                                                                                                                                              0.0s 
 => [stage-0 3/6] COPY requirements.txt /app                                                                                                                                                                                                                                                                       0.0s 
 => [stage-0 4/6] RUN --mount=type=cache,target=/root/.cache/pip     
                      pip3 install -r requirements.txt                                                                                                                                                                                                              7.2s 
 => [stage-0 5/6] COPY . .                                                                                                                                                                                                                                                                                         0.3s 
 => [stage-0 6/6] RUN python init_db.py                                                                                                                                                                                                                                                                            1.5s 
 => exporting to image                                                                                                                                                                                                                                                                                             0.3s 
 => => exporting layers                                                                                                                                                                                                                                                                                            0.3s 
 => => writing image sha256:2671ccb7546a0594807c721a0600a                                                                                                                                                                                                                       0.0s 
 => => naming to docker.io/library/flask-watchlist:1.0 

Jika Anda mencantumkan gambar, Anda akan melihat gambar baru kami:

$ docker images

REPOSITORY        TAG       IMAGE ID       CREATED       SIZE
flask-watchlist   1.0       7bce66230eb1   8 hours ago   110MB

Terakhir, gunakan gambar untuk memutar kontainer Docker baru:

$ docker run -it -p 5000:5000 flask-watchlist:1.0

[2023-02-02 20:08:57 +0000] [1] [INFO] Starting gunicorn 20.1.0
[2023-02-02 20:08:57 +0000] [1] [INFO] Listening at: http://0.0.0.0:5000 (1)
[2023-02-02 20:08:57 +0000] [1] [INFO] Using worker: sync
[2023-02-02 20:08:57 +0000] [7] [INFO] Booting worker with pid: 7
[2023-02-02 20:08:57 +0000] [8] [INFO] Booting worker with pid: 8

Anda dapat menggunakan -d untuk memulai kontainer Docker dalam mode terpisah. Artinya, kontainer berjalan di latar belakang terminal Anda dan tidak menerima masukan atau menampilkan keluaran.

Bagus, aplikasi Anda sekarang sudah berjalan di dalam kontainer! Buka http://localhost:5000 dan Anda akan mendapatkan respons berikut ini:

{
    "name": "flask-watchlist",
    "description": "a simple app for tracking the movies you want to watch",
    "version": 1
}

GitHub

Untuk menerapkan aplikasi ke Back4app Containers, Anda harus mengunggah kode sumber ke repositori GitHub. Lanjutkan dengan membuat repositori baru di GitHub, tambahkan remote, tambahkan .gitignore, dan komit kode Anda. Setelah kode Anda ada di GitHub, lanjutkan ke langkah berikutnya.

Menyebarkan Aplikasi ke Wadah Back4app

Langkah-langkah berikut ini mengharuskan Anda memiliki akun Back4app. Jika Anda sudah memilikinya, silakan masuk dan mendaftar untuk akun gratis.

Untuk bekerja dengan Back4app, pertama-tama kita perlu membuat aplikasi. Saat Anda masuk ke dasbor, Anda akan melihat daftar aplikasi Anda. Klik pada “Buat aplikasi baru” untuk membuat aplikasi baru.

Selanjutnya, pilih “Kontainer sebagai Layanan”.

Jika Anda belum melakukannya, silakan hubungkan GitHub Anda ke Back4app dan impor repositori yang ingin Anda gunakan. Setelah GitHub Anda terhubung, repositori Anda akan ditampilkan dalam tabel.

Pilih repositori yang ingin Anda gunakan dengan mengeklik “Pilih”.

Selanjutnya, Back4app akan meminta Anda untuk mengonfigurasi lingkungan. Pilih nama aplikasi, saya akan memilih flask-watchlist. Jangan ragu untuk membiarkan yang lainnya sebagai default.

Terakhir, klik “Buat Aplikasi” untuk membuat aplikasi secara otomatis dan menerapkannya.

Anda kemudian akan diarahkan ke detail aplikasi di mana Anda bisa melihat log penyebaran.

Tunggu beberapa menit hingga aplikasi diterapkan dan voila! Aplikasi Anda sekarang sudah tayang di Back4app Containers. Untuk melihat aplikasi Anda beraksi, klik URL hijau yang ditampilkan di sebelah kiri.

Kesimpulan

Di sepanjang artikel, kami telah menjelaskan apa itu kontainer, manfaatnya, dan mendemonstrasikan bagaimana Anda dapat mengimplementasikan kontainer ke dalam alur kerja Anda. Sekarang Anda seharusnya sudah bisa membuat REST API sederhana Anda sendiri, melakukan dockerisasi, dan men-deploy-nya ke Back4app Containers.

Ambil kode sumber akhir dari repositori GitHub.

Langkah-langkah ke depan

1. Anda tidak boleh menyimpan basis data di dalam gambar Anda. Saat ini, setiap penerapan ulang akan mengatur ulang basis data. Pertimbangkan untuk beralih ke instans PostgreSQL atau MySQL yang terkelola.
2. Pelajari tentang build multi-tahap untuk mengoptimalkan Dockerfile Anda.
3. Baca artikel Menyebarkan Kontainer Docker untuk tutorial langkah demi langkah

PERTANYAAN YANG SERING DIAJUKAN