PricingLoginStart free
Kem Intensif Pembangunan Bahagian Belakang FastAPI · Pelajaran

Membina Bekas Aplikasi FastAPI

Pelajari cara membina bekas untuk perkhidmatan FastAPI anda menggunakan Docker, sambil mencipta imej penggunaan yang cekap dan mudah alih.

Pelajaran 1 daripada 412 langkah

Membina Bekas Aplikasi FastAPI ialah pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Kem Intensif Pembangunan Bahagian Belakang FastAPI merangkumi sejumlah 4 pelajaran.

Docker dan FastAPI: Mengapa Menggunakan Bekas?

Selamat datang! Dalam pelajaran ini, kita akan belajar cara membungkus aplikasi FastAPI anda menggunakan Docker. Ini menjadikan aplikasi anda sangat konsisten dan mudah digunakan di mana-mana sahaja.

  • Apakah Docker? Docker ialah platform yang menggunakan pemayaan pada tahap OS untuk menyampaikan perisian dalam pakej yang dipanggil bekas.
  • Mengapa menggunakannya untuk FastAPI? Docker menyelesaikan masalah "ia berfungsi pada mesin saya" dengan membungkus aplikasi dan kebergantungannya bersama-sama.

Teras Docker: Imej dan Bekas

Sebelum kita mendalami proses menjadikan aplikasi sebagai bekas Docker, mari fahami dua konsep utama:

  • Imej Docker: Anggap imej sebagai pelan atau templat. Ia ialah fail statik dan tidak berubah yang mengandungi kod aplikasi, pustaka, kebergantungan serta konfigurasi anda.
  • Bekas Docker: Bekas ialah tika imej yang boleh dijalankan. Ia merupakan persekitaran terpencil tempat aplikasi anda berjalan, sepenuhnya berasingan daripada sistem hos anda.

Anda membina imej, kemudian menjalankan bekas daripadanya.

Perkhidmatan FastAPI Asas

Mari mulakan dengan aplikasi FastAPI ringkas yang akan kita jadikan bekas. Fail ini akan dinamakan main.py.

Aplikasi ini mempunyai satu titik akhir yang mengembalikan mesej 'Hello'.

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    return {"message": "Hello from FastAPI!"}

# To run locally (without Docker):
# uvicorn main:app --host 0.0.0.0 --port 8000

Dockerfile: Permulaan yang Kukuh

Dockerfile ialah fail teks yang mengandungi semua perintah yang boleh dipanggil oleh pengguna pada baris perintah untuk memasang imej. Ia ialah resipi anda untuk membina imej.

Kita bermula dengan memilih imej asas dan menetapkan direktori kerja:

  • FROM: Menentukan imej asas, contohnya versi Python.
  • WORKDIR: Menetapkan direktori kerja semasa di dalam bekas.
# Dockerfile
FROM python:3.9-slim-buster
WORKDIR /app

Kebergantungan FastAPI: requirements.txt

Aplikasi FastAPI anda memerlukan pakej Python tertentu untuk dijalankan. Kita menyenaraikannya dalam fail requirements.txt. Fail ini memberitahu Docker pakej yang perlu dipasang di dalam bekas.

Berikut ialah requirements.txt biasa untuk aplikasi FastAPI ringkas kita:

# requirements.txt
fastapi==0.104.1
uvicorn[standard]==0.24.0.post1

Dockerfile: Memasang Kebergantungan

Sekarang, mari tambahkan perintah pada Dockerfile untuk menyalin dan memasang kebergantungan ini:

  • COPY requirements.txt .: Menyalin requirements.txt daripada mesin tempatan anda ke direktori /app dalam bekas.
  • RUN pip install ...: Melaksanakan perintah untuk memasang semua pakej yang disenaraikan dalam requirements.txt. --no-cache-dir membantu mengekalkan saiz imej agar kecil.
# Dockerfile (continued)
FROM python:3.9-slim-buster
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

Dockerfile: Kod Aplikasi dan Titik Masuk

Akhir sekali, kita menambahkan kod aplikasi dan memberitahu Docker cara menjalankannya:

  • COPY . .: Menyalin semua fail yang berbaki daripada direktori semasa anda, termasuk main.py, ke dalam direktori /app dalam bekas.
  • EXPOSE 8000: Memaklumkan Docker bahawa bekas mendengar pada port 8000. Ini ialah dokumentasi, bukan peraturan tembok api.
  • CMD [...]: Menentukan perintah yang perlu dijalankan apabila bekas bermula. Inilah cara Uvicorn menyampaikan aplikasi FastAPI anda.
# Dockerfile (final)
FROM python:3.9-slim-buster
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Membina Imej Docker Anda

Dengan Dockerfile dan aplikasi FastAPI anda yang telah siap, tibalah masanya untuk membina imej Docker!

Buka terminal anda dalam direktori yang sama dengan Dockerfile dan main.py, kemudian jalankan:

  • docker build .: Memberitahu Docker untuk membina imej menggunakan Dockerfile dalam direktori semasa.
  • -t myfastapi-app: Menandakan imej dengan nama (myfastapi-app) supaya mudah dirujuk.
# Terminal Command
docker build -t myfastapi-app .

Menjalankan Bekas FastAPI Anda

Setelah imej dibina, anda boleh menjalankan aplikasi FastAPI dalam bekas!

Gunakan perintah docker run:

  • -p 8000:8000: Memetakan port 8000 pada mesin hos anda kepada port 8000 di dalam bekas.
  • myfastapi-app: Nama imej yang baru kita bina.

Selepas menjalankannya, buka pelayar anda atau gunakan curl untuk melawati http://localhost:8000.

# Terminal Command
docker run -p 8000:8000 myfastapi-app

Memperkenalkan Docker Compose

Untuk aplikasi dengan berbilang perkhidmatan, seperti aplikasi FastAPI dan pangkalan data, Docker Compose memudahkan pengurusan. Ia membolehkan anda mentakrif dan menjalankan aplikasi Docker berbilang bekas menggunakan fail YAML.

Daripada menjalankan berbilang perintah docker run, anda mentakrifkan semuanya dalam docker-compose.yml dan menggunakan docker-compose up.

# docker-compose.yml (simplified)
version: '3.8'
services:
  web:
    build: .
    ports:
      - "8000:8000"

Semakan Perintah Dockerfile

Perintah Dockerfile yang manakah digunakan untuk menyalin fail atau direktori daripada mesin tempatan anda ke dalam imej Docker?

Jawab dalam pelajaran interaktif

Ulang Kaji: FastAPI dalam Kotak!

Tahniah! Anda telah mempelajari asas menjadikan aplikasi FastAPI anda sebagai bekas Docker. Kita telah membincangkan:

  • Perbezaan antara Imej dan Bekas Docker.
  • Menulis Dockerfile dengan perintah seperti FROM, WORKDIR, COPY, RUN, EXPOSE dan CMD.
  • Membina dan menjalankan aplikasi FastAPI anda dalam bekas Docker.
  • Pengenalan ringkas kepada Docker Compose untuk aplikasi berbilang perkhidmatan.

Kemahiran ini penting untuk penggunaan yang konsisten dan boleh diskalakan!

Percuma untuk bermula

Pelajari Kem Intensif Pembangunan Bahagian Belakang FastAPI dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus
21
Pelajaran
84
Mula belajar secara percumaLihat kursus penuh

Soalan Lazim

Adakah pelajaran “Membina Bekas Aplikasi FastAPI” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI, termasuk “Membina Bekas Aplikasi FastAPI”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Kem Intensif Pembangunan Bahagian Belakang FastAPI merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Membina Bekas Aplikasi FastAPI”?

Pelajari cara membina bekas untuk perkhidmatan FastAPI anda menggunakan Docker, sambil mencipta imej penggunaan yang cekap dan mudah alih. Anda berlatih Kem Intensif Pembangunan Bahagian Belakang FastAPI menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Kem Intensif Pembangunan Bahagian Belakang FastAPI?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Membina Bekas Aplikasi FastAPI” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI ini?

Ya. Setiap pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

  1. Membina Bekas Aplikasi FastAPI
  2. Penggunaan dengan Gunicorn dan Uvicorn
  3. Strategi Penggunaan Awan
  4. Mengurus Pemboleh Ubah Persekitaran dan Rahsia
← Kembali ke Kem Intensif Pembangunan Bahagian Belakang FastAPI