---
title: ایجاد و نصب برنامه وب پایتون
description: یاد بگیرید که برنامه‌های وب پایتون را با استفاده از چارچوب‌هایی مانند Flask، Django، FastAPI، Pyramid و Tornado برای استقرارهای مداوم، کانتینرایز کنید.
url: "https://negarnovin.com/docs/how-to-containerize-python-web-applications/"
updated: "2026-09-05"
category: تحقیق و توسعه / پایتون
---

# ایجاد و نصب برنامه وب پایتون

# نحوه کانتینرایز کردن برنامه های وب پایتون

 یاد بگیرید که برنامه های وب پایتون را با استفاده از چارچوب هایی مانند Flask، Django، FastAPI، Pyramid و Tornado برای استقرارهای مداوم، کانتینرایز کنید.

 

## مقدمه

کانتینریزه کردن برنامه های وب پایتون، ساختار برنامه و وابستگی های آن را در یک بسته واحد کپسوله می کند تا از استقرارهای سازگار و قابل تکرار در محیط های مختلف اطمینان حاصل شود. استقرار برنامه های وب پایتون کانتینریزه شده، یک رویکرد اساسی برای توسعه نرم افزار مدرن است که شامل مقیاس بندی و اتوماسیون هنگام استقرار در پلتفرم هایی مانند Kubernetes می شود.

شما می توانید برنامه های پایتون را با استفاده از چارچوب های توسعه مختلف بسازید. هر پلتفرم ممکن است به رویکردی کمی متفاوت برای کانتینر کردن و ارسال تصویر برنامه نیاز داشته باشد. چارچوب های محبوب پایتون عبارتند از:

- **Flask** : یک چارچوب وب سبک و انعطاف پذیر که ابزارهای ضروری برای ساخت برنامه های وب را فراهم می کند. این چارچوب مینیمالیستی است و ابزارهای مستقیمی ارائه می دهد که به توسعه دهندگان اجازه می دهد کتابخانه ها را بر اساس نیازهای خاص پروژه اضافه کنند.
- **جنگو** : یک چارچوب وب فول استک سطح بالا که مجموعه ای کامل از ابزارها و کتابخانه ها را برای ساخت برنامه های وب قوی فراهم می کند.
- **FastAPI** : یک چارچوب وب مدرن و با کارایی بالا برای ساخت APIها با پایتون. این چارچوب از type hints برای فعال کردن مستندسازی API تعاملی خودکار (با استفاده از Swagger UI) استفاده می کند و با استفاده از سیستم نوع پایتون، کارایی بالایی را ارائه می دهد.
- **Pyramid** : یک چارچوب انعطاف پذیر و مقیاس پذیر که به توسعه دهندگان اجازه می دهد اجزای مورد نیاز برای برنامه های خود را انتخاب کنند.
- **Tornado** : یک کتابخانه شبکه ناهمزمان و چارچوب وب که در درجه اول به دلیل عملکرد بالا و توانایی مدیریت بسیاری از اتصالات همزمان شناخته شده است.

این مقاله نحوه کانتینرایز کردن برنامه های وب پایتون برای استقرار در محیط های عملیاتی مانند کلاسترهای Kubernetes را توضیح می دهد.

## پیش نیازها

قبل از شروع:

- یک کلاستر Kubernetes Engine (VKE) را برای استفاده به عنوان پلتفرم استقرار در محیط عملیاتی، مستقر کنید.
- برای ذخیره تصویر برنامه پایتون، یک رجیستری کانتینر ایجاد کنید.
- یک داکر برای استفاده به عنوان ایستگاه کاری مدیریت نصب کنید.
- با استفاده از SSH به عنوان یک کاربر غیر ریشه با امتیازات sudo به ایستگاه کاری دسترسی پیدا کنید .
- Kubectl را برای دسترسی به کلاستر نصب و پیکربندی کنید .
- برای نصب برنامه های خوشه ای اضافی، ابزار Helm CLI را نصب کنید.  console
  ```
  $ sudo snap install helm --classic
  ```

## ایجاد یک برنامه وب پایتون

برای ایجاد یک تصویر ثابت از برنامه وب پایتون که بتوانید با چارچوب های مختلفی مانند Flask یا Django از آن استفاده کنید، کد خود را طوری ساختار دهید که منطق رابط کاربری HTTP [سرور](https://negarnovin.com/unlimited-traffic-virtual-server/) frontend از منطق اصلی برنامه جدا باشد. مراحل زیر را برای ایجاد یک برنامه پایه پایتون با استفاده `app.py`از فایل اصلی برنامه و استفاده از یک `server.py`فایل برای گنجاندن منطق اولیه HTTP سرور دنبال کنید.

1. محیط مجازی پایتون و مدیر بسته PIP را نصب کنید.  کنسول
   ```
   $ sudo apt install python3-venv python3-pip -y
   ```
2. یک دایرکتوری پروژه جدید برای ذخیره فایل های برنامه ایجاد کنید.  کنسول
   ```
   $ mkdir python-app
   ```
3. به دایرکتوری تغییر دهید.  کنسول
   ```
   $ cd python-app
   ```
4. یک محیط مجازی پایتون جدید ایجاد کنید تا وابستگی های برنامه را از سایر بسته های سیستم جدا کنید.  کنسول
   ```
   $ python3 -m venv python-env
   ```
5. محیط مجازی را فعال کنید.  کنسول
   ```
   $ source python-env/bin/activate
   ```
6. فایل اصلی برنامه را `app.py`با استفاده از یک ویرایشگر متن مانند Nano ایجاد کنید.  کنسول
   ```
   (python-env)$ nano app.py
   ```
7. کد زیر را به فایل اضافه کنید.  python
   ```
   def hello_world():
    print("Hello, World!")
   
   if __name__ == "__main__":
    hello_world()
   ```

   فایل را ذخیره کنید و ببندید.

   کد بالا یک برنامه وب پایتون پایه ایجاد می کند که یک `Hello, World!`اعلان نمایش می دهد. درون برنامه:

   - این `hello_world`تابع `Hello, World!`هنگام فراخوانی، رشته را چاپ می کند.
   - `if __name__ == "__main__":`: بررسی می کند که آیا اسکریپت به عنوان برنامه اصلی اجرا می شود یا خیر. این تضمین می کند که عناصر کد خاصی هنگام شروع اسکریپت با نخ اصلی اجرا شوند. اگر اسکریپت برنامه اصلی باشد، `hello_world`تابع را فراخوانی می کند.
8. یک فایل جدید `server.py`برای راه اندازی یک برنامه HTTP پایه با استفاده از پایتون `http.server`و `socketserver`ماژول ها ایجاد کنید.  کنسول
   ```
   (python-env)$ nano server.py
   ```
9. کد زیر را به فایل اضافه کنید.  پایتون
   ```
   from http.server import SimpleHTTPRequestHandler
   from socketserver import TCPServer
   from threading import Thread
   
   class HelloWorldHandler(SimpleHTTPRequestHandler):
    def do_GET(self):
    # Handle GET requests
    self.send_response(200)
    self.send_header("Content-type", "text/plain")
    self.end_headers()
    self.wfile.write(b"Hello, World!")
   
   def start_server():
    # Set up the HTTP server with custom handler
    server_address = ("", 8000)
    httpd = TCPServer(server_address, HelloWorldHandler)
   
    print("Server is running at http://localhost:8000")
   
    try:
    # Serve indefinitely
    httpd.serve_forever()
    except KeyboardInterrupt:
    # Handle keyboard interrupt to gracefully shut down the server
    print("Shutting down the server.")
    httpd.shutdown()
   
   if __name__ == "__main__":
    # Start the server in a separate thread
    server_thread = Thread(target=start_server)
    server_thread.start()
   
    # Run the main application
    from app import hello_world
    hello_world()
   
    # Wait for the server thread to finish
    server_thread.join()
   ```

   فایل را ذخیره کنید و ببندید.

   کد برنامه فوق به درخواست های GET ورودی با یک `Hello, World!`اعلان پاسخ می دهد. درون کد:

   - `HelloWorldHandler`: یک کلاس هندلر سفارشی تعریف می کند که `SimpleHTTPRequestHandler`تابع ماژول HTTP را برای مدیریت درخواست های GET به ارث می برد.
   - `start_server`: یک `TCPServer`نمونه در حال اجرا روی پورت میزبان ایجاد می کند. علاوه بر این، استثنائات + وقفه ها را `8000`ضبط می کند تا سرور را به طور مناسب خاموش کند.`KeyboardInterrupt``Ctrl``C`
   - `(if __name__ == "__main__":)`سرور HTTP را با استفاده از تابع در یک نخ جداگانه اجرا می کند . سپس، یک تابع را از ماژول `Thread(target=start_server)`وارد و فراخوانی می کند . قبل از بستن اتصال، منتظر می ماند تا نخ سرور تکمیل شود.`hello_world``app``server_thread.join()`
10. برنامه پایتون را به عنوان یک وظیفه پس زمینه در جلسه سرور خود اجرا کنید.  کنسول
    ```
    (python-env)$ python3 server.py &
    ```

    خروجی:

    ```
    Server is running at http://localhost:8000
    ```
11. `8000`برای تأیید دسترسی به برنامه، یک درخواست GET به پورت میزبان ارسال کنید .  کنسول
    ```
    (python-env)$ curl -X GET -H "Content-Type: application/json" http://localhost:8000
    ```

    خروجی:

    ```
    Hello, World!
    ```

    وقتی درخواست GET فوق با شکست مواجه شد، بررسی کنید که هیچ برنامه ی ناسازگاری روی پورت میزبان تعریف شده اجرا نشود `8000`.
12. شناسه کار برنامه پس زمینه را مشاهده کنید.  کنسول
    ```
    $ jobs
    ```

    خروجی:

    ```
    [1] python3 server.py &
    ```
13. برنامه را با استفاده از شناسه شغل متوقف کنید. برای مثال `1`.  کنسول
    ```
    (python-env)$ kill %1
    ```
14. محیط مجازی خود را غیرفعال کنید.  کنسول
    ```
    (python-env)$ deactivate
    ```

## کانتینرایز کردن برنامه وب پایتون

1. یک Dockerfile جدید `Dockerfile`برای تنظیم تصویر کانتینر برنامه پایتون خود ایجاد کنید.  کنسول
   ```
   $ nano Dockerfile
   ```
2. محتویات زیر را به فایل اضافه کنید.  Dockerfile
   ```
   FROM python:3.8-slim
   WORKDIR /app
   
   COPY . /app
   
   CMD ["python3", "./server.py"]
   ```

   فایل را ذخیره کنید و ببندید.

   پیکربندی Dockerfile فوق، دایرکتوری کانتینر پایتون و ساختار زمان اجرا را تعریف می کند. در داخل پیکربندی:

   - `FROM python:3.8-slim`: از ایمیج رسمی پایتون ۳.۸ به عنوان ایمیج پایه برای اجرای کانتینر استفاده می کند.
   - `WORKDIR /app`دایرکتوری کاری را `/app`داخل کانتینر تنظیم می کند.
   - `COPY . /app`: داده ها را از دایرکتوری پروژه شما به کانتینر کپی می کند.
   - `CMD ["python3", "./server.py"]`: `server.py`اسکریپت را هنگام شروع کانتینر اجرا می کند.
3. ایمیج داکر را با تمام فایل های دایرکتوری بسازید.  کنسول
   ```
   $ docker build -t python-app .
   ```
4. برای تأیید در دسترس بودن برنامه، تصاویر محلی Docker را مشاهده کنید.  کنسول
   ```
   $ docker images
   ```

   خروجی:

   ```
   REPOSITORY TAG IMAGE ID CREATED SIZE
   python-app latest 86ff1e8041fe 19 seconds ago 180MB
   ```

## تصویر برنامه پایتون را به رجیستری کانتینر نگارنوین منتقل کنید

برای ذخیره و استفاده از تصویر برنامه پایتون روی پلتفرمی مانند Kubernetes، تصویر را به رجیستری کانتینر نگارنوین منتقل کنید تا آن را به محیط های هدف خود ارسال کنید، همانطور که در مراحل زیر توضیح داده شده است.

1. وارد رجیستری کانتینر نگارنوین خود شوید. به جای ،، `pythonregistry`جزئیات رجیستری واقعی خود را قرار دهید.`vcr-user``vcr-password`  کنسول
   ```
   $ docker login https://sjc.negarnovin.com/pythonregistry -u vcr-user -p vcr-password
   ```
2. ایمیج محلی داکر را با مخزن رجیستری کانتینر نگارنوین هدف خود برچسب گذاری کنید.  کنسول
   ```
   $ docker tag python-app:latest sjc.negarnovin.com/pythonregistry/python-app:latest
   ```
3. لیست تصاویر Docker موجود را مشاهده کنید و تأیید کنید که تصویر رجیستری در دسترس است.  کنسول
   ```
   $ docker images
   ```

   خروجی:

   ```
   sjc.negarnovin.com/pythonregistry/python-app latest 5594b65d7cd5 3 minutes ago 159MB
   python-app latest 01acb92c461c 3 minutes ago 159MB
   python 3.8-slim 067655fb1c09 2 months ago 128MB
   ```
4. تصویر برنامه پایتون خود را به رجیستری کانتینر نگارنوین منتقل کنید.  کنسول
   ```
   $ docker push sjc.negarnovin.com/pythonregistry/python-app:latest
   ```

   خروجی:

   ```
   The push refers to repository [sjc.negarnovin.com/pythonregistry/python-app]
   1.2e1e26d6f: Pushed
   1.df21a05: Pushed
   b081d565ce24: Pushed
   e67a1acfc698: Pushed
   1.8551e70: Pushed
   da5d55102092: Pushed
   fb1bd2fc5282: Pushed
   latest: digest: sha256:4a523aab91202e4d79d9456672571ae855a7227590d2dd63de11498bf64f098c size: 1788
   ```
5. برای آزمایش دسترسی به برنامه، یک کانتینر داکر جدید با استفاده از تصویر کانتینر رجیستری خود راه اندازی کنید.  کنسول
   ```
   $ docker run -dit -p 8000:8000 sjc.negarnovin.com/pythonregistry/python-app:latest
   ```
6. برای تأیید اینکه کانتینر برنامه شما در دسترس است، لیست کانتینرهای داکر در حال اجرا را مشاهده کنید.  کنسول
   ```
   $ docker ps
   ```

   خروجی:

   ```
   CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
   cfaf3ab6bfac python-app:latest "python3 ./server.py" 8 seconds ago Up 7 seconds 0.0.0.0:8000->8000/tcp, :::8000->8000/tcp jovial_brattain
   ```
7. `8000`برای تأیید دسترسی به کانتینر برنامه، یک درخواست GET جدید به پورت میزبان ارسال کنید .
   ```
   $ curl -X GET -H "Content-Type: application/json" http://127.0.0.1:8000
   ```

   خروجی:

   ```
   Hello, World!
   ```

## استقرار برنامه پایتون در یک کلاستر Kubernetes

برای استقرار ایمن برنامه پایتون کانتینر شده خود در یک محیط عملیاتی مانند خوشه Kubernetes، دسترسی به رجیستری کانتینر نگارنوین خود را تنظیم کرده و تصویر برنامه را به عنوان یک منبع استقرار جدید نصب کنید. هنگام استقرار، کانتینر برنامه شما به اتصالات ورودی روی پورتی `8000`که در پیکربندی کانتینر تعریف شده است، گوش می دهد. برای استقرار و استفاده از تصویر برنامه پایتون خود در یک خوشه negarnovin Kubernetes Engine (VKE) مراحل زیر را دنبال کنید.

1. به کنترل پنل رجیستری کانتینر نگارنوین خود دسترسی پیدا کنید.
2. به برگه **Docker/Kubernetes** بروید و روی **Generate Kubernetes YAML** کلیک کنید تا یک رجیستری جدید برای پیکربندی منابع مخفی ایجاد شود.
   ![ایجاد و نصب برنامه وب پایتون](https://negarnovin.com/wp-content/uploads/2025/09/2e33d3cdb8c6d366_compressed.webp)
   ایجاد و نصب برنامه وب پایتون
3. یک فایل منبع مخفی جدید ایجاد کنید `secret.yaml`.  کنسول
   ```
   $ nano secret.yaml
   ```
4. پیکربندی YAML رجیستری کانتینر نگارنوین تولید شده خود را به فایلی مشابه فایل زیر اضافه کنید:
   ```
   apiVersion: v1
   kind: Secret
   metadata:
    name: negarnovin-cr-credentials
   data:
    .dockerconfigjson: example-json
   type: kubernetes.io/dockerconfigjson
   ```

   فایل را ذخیره کنید و ببندید.
5. راز را در کلاستر خود مستقر کنید.  کنسول
   ```
   $ kubectl apply -f secret.yaml
   ```
6. منابع کلاستر را مشاهده کنید تا مطمئن شوید که اعتبارنامه های رجیستری شما آماده استفاده هستند.  کنسول
   ```
   $ kubectl get secret
   ```

   خروجی:

   ```
   NAME TYPE DATA AGE
   negarnovin-cr-credentials kubernetes.io/dockerconfigjson 1 29m
   ```
7. یک فایل منبع Deployment جدید ایجاد کنید `deployment.yaml`تا نحوه اجرای برنامه خود را در یک pod شرح دهید.  کنسول
   ```
   $ nano deployment.yaml
   ```
8. پیکربندی های زیر را به فایل اضافه کنید. آن را `sjc.negarnovin.com/pythonregistry/python-app:latest`با مخزن رجیستری NegarNovin Container واقعی خود جایگزین کنید.  yaml
   ```
   kind: Deployment
   apiVersion: apps/v1
   metadata:
    name: python-app
   spec:
    replicas: 3
    selector:
    matchLabels:
    app: python-app
    template:
    metadata:
    labels:
    app: python-app
    spec:
    containers:
    - name: python-app
    image: sjc.negarnovin.com/pythonregistry/python-app:latest
    ports:
    - containerPort: 8000
    imagePullSecrets:
    - name: negarnovin-cr-credentials
   ```

   فایل را ذخیره کنید و ببندید.
9. استقرار را روی کلاستر خود اعمال کنید.  کنسول
   ```
   $ kubectl apply -f deployment.yaml
   ```
10. برای تأیید در دسترس بودن منبع جدید، استقرارهای کلاستر را مشاهده کنید.  کنسول
    ```
    $ kubectl get deployment
    ```

    خروجی:

    ```
    NAME READY UP-TO-DATE AVAILABLE AGE
    python-app 3/3 3 3 21s
    ```
11. برای تأیید تمام پادهای مرتبط با استقرار خود، پادهای کلاستر را مشاهده کنید.  کنسول
    ```
    $ kubectl get pods
    ```

    خروجی:

    ```
    NAME READY STATUS RESTARTS AGE
    python-app-6cb76cfc8d-5wjbf 1/1 Running 0 35s
    python-app-6cb76cfc8d-tphrx 1/1 Running 0 35s
    python-app-6cb76cfc8d-txk5p 1/1 Running 0 35s
    ```

## دسترسی خارجی به برنامه پایتون را به طور ایمن در معرض دید قرار دهید

برای اینکه برنامه پایتون خود را برای دسترسی خارجی با استفاده از خوشه negarnovin Kubernetes Engine (VKE) خود در معرض نمایش قرار دهید، یک کنترل کننده Ingress نصب کنید تا سرویس برنامه شما را به یک نام دامنه نگاشت کند. این کنترل کننده به طور ایمن تمام درخواست های برنامه را از نام دامنه شما به سرویس برنامه پایتون backend هدایت می کند. برای نمایش برنامه در خوشه VKE خود، مراحل زیر را دنبال کنید.

1. مخزن ورودی NGINX را به منابع Helm خود اضافه کنید.  کنسول
   ```
   $ helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
   ```
2. فهرست مخزن Helm را به روزرسانی کنید.  کنسول
   ```
   $ helm repo update
   ```
3. NGINX Ingress Controller را با استفاده از Helm روی کلاستر خود نصب کنید.  کنسول
   ```
   $ helm install nginx-ingress ingress-nginx/ingress-nginx --set controller.publishService.enabled=true
   ```
4. حداقل `3`چند دقیقه صبر کنید تا Nginx Ingress Controller تمام CRD های لازم را نصب کند. سپس، سرویس های کنترلر را مشاهده کنید تا آدرس IP اختصاص داده شده به Load Balancer را تأیید کنید.  کنسول
   ```
   $ kubectl get service --namespace default nginx-ingress-ingress-nginx-controller
   ```

   خروجی:

   ```
   NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
   nginx-ingress-ingress-nginx-controller LoadBalancer 10.98.94.149 192.0.2.100 80:32671/TCP,443:32325/TCP 2m58s
   ```

   برای دسترسی خارجی به سرویس های کلاستر خود، مقدار **EXTERNAL-IP** کنترلر Ingress را یادداشت کنید .
5. **یک رکورد دامنه A** جدید که به آدرس IP عمومی کنترل کننده Ingress اشاره می کند، تنظیم کنید . برای مثال، `app.example.com`.
6. یک فایل منبع سرویس پایتون جدید ایجاد کنید`service.yaml`  کنسول
   ```
   $ nano service.yaml
   ```
7. محتویات زیر را به فایل اضافه کنید.  یامل
   ```
   apiVersion: v1
   kind: Service
   metadata:
    name: python-app
   spec:
    selector:
    app: python-app
    ports:
    - protocol: TCP
    port: 80
    targetPort: 8000
   ```

   فایل را ذخیره کنید و ببندید.

   پیکربندی سرویس فوق، تمام درخواست های شبکه روی پورت HTTP را `80`به پورت برنامه پایتون شما ارسال می کند `8000`.
8. سرویس را روی کلاستر خود اعمال کنید.  کنسول
   ```
   $ kubectl apply -f service.yaml
   ```
9. یک فایل منبع Ingress جدید `ingress.yaml`برای نمایش سرویس برنامه پایتون ایجاد کنید.  کنسول
   ```
   $ nano ingress.yaml
   ```
10. محتویات زیر را به فایل اضافه کنید. `app.example.com`دامنه واقعی خود را جایگزین کنید.  یامل
    ```
    apiVersion: networking.k8s.io/v1
    kind: Ingress
    metadata:
     name: nginx-ingress
     namespace: default
     annotations:
     kubernetes.io/ingress.class: nginx
    spec:
     rules:
     - host: app.example.com
     http:
     paths:
     - backend:
     service:
     name: python-app
     port:
     number: 80
     path: /
     pathType: Prefix
    ```

    فایل را ذخیره کنید و ببندید.

    پیکربندی Ingress فوق، تمام درخواست های ریشه را از `app.example.com`سرویس برنامه پایتون شما روی پورت ارسال می کند `80`.
11. منبع Ingress را روی کلاستر خود اعمال کنید.  کنسول
    ```
    $ kubectl apply -f ingress.yaml
    ```
12. اشیاء Ingress کلاستر را مشاهده کنید و تأیید کنید که منبع جدید در دسترس است.  کنسول
    ```
    $ kubectl get ingress
    ```

    خروجی:

    ```
    NAME CLASS HOSTS ADDRESS PORTS AGE
    nginx-ingress nginx app.example.com 192.0.2.100 80 32s
    ```
13. برای آزمایش دسترسی به برنامه، با استفاده از یک مرورگر وب مانند فایرفاکس به دامنه خود دسترسی پیدا کنید.
    ![ایجاد و نصب برنامه وب پایتون](https://negarnovin.com/wp-content/uploads/2025/09/6cb69bfce5b64897_compressed.webp)

## نتیجه گیری

شما یک برنامه پایتون را کانتینرایز کرده اید و آن را در مخزن رجیستری کانتینر نگارنوین برای استقرار در یک خوشه VKE ذخیره کرده اید. ارسال برنامه های وب پایتون به عنوان تصاویر کانتینر، مدیریت و ارتقاء کارآمد اجزای برنامه را برای استقرار در محیط های مختلف امکان پذیر می کند.

   نحوه کانتینرایز کردن برنامه های وب پایتونمقدمهپیش نیازهاخرید ایجاد و نصب برنامه وب پایتونقیمت ایجاد و نصب برنامه وب پایتونبهترین ایجاد و نصب برنامه وب پایتون
