ما هي الحاويات في الحوسبة السحابية؟

منذ أن ظهرت حاويات Docker على الساحة في عام 2013 ازدادت شعبية الحاويات. وقد قامت الكثير من الشركات بالفعل بدمج الحاويات في سير عملها لأنها تتيح لها نشر برامجها وتوزيعها وإدارتها وتوسيع نطاقها بسهولة.

سنشرح في هذه المقالة ما هي الحاويات في الحوسبة السحابية. سنتحدث عن فوائد استخدام الحاويات، وحالات استخدامها، ومقارنتها بالأجهزة الافتراضية، وسنلقي نظرة على Docker و Kubernetes. أخيرًا، سنعلمك كيفية ترميز تطبيق ويب وإرساءه ونشره على حاويات Back4app – مجانًا تمامًا!

تعريف الحاوية

الحاوية عبارة عن حزمة مستقلة قابلة للتنفيذ تتضمن كل ما يلزم لتشغيل تطبيق ما: التعليمات البرمجية ووقت التشغيل والمكتبات ومتغيرات البيئة وملفات التهيئة. الشيء الرائع في التطبيقات الموضوعة في حاويات هو أنه يمكن تشغيلها في أي مكان، بدءًا من بيئة التطوير المحلية إلى السحابة العامة وما إلى ذلك. الحاويات صغيرة الحجم وفعالة وتسمح بالعزل الفعال.

فوائد استخدام الحاويات

استخدام الحاويات له فوائد عديدة. دعونا نلقي نظرة على بعضها.

الكفاءة

تتطلب الحاويات موارد نظام أقل من الخوادم التقليدية أو الأجهزة الافتراضية لأنها لا تتضمن صورة نظام تشغيل. وهذا يجعلها فعالة للغاية وصغيرة الحجم (تقاس عادةً بالميغابايت) وتسمح لك بتشغيل عدد كبير من التطبيقات على خادم واحد.

عزل التطبيق

تعزل الحاويات التطبيق وتوابعه عن النظام المضيف. وفي الوقت نفسه، يمكنها مشاركة نواة نظام التشغيل وموارد النظام مثل وحدة المعالجة المركزية والذاكرة والتخزين والشبكة.

قابلية النقل

يمكن تشغيل البرمجيات الحاوية والتصرف بنفس الطريقة على أي جهاز مثبت عليه محرك الحاوية. هذا يجعل من السهل نشر التطبيقات ونقلها بين البيئات المختلفة ويزيل مشكلة “إنها تعمل على جهازي”.

الفصل بين المسؤولية

تتيح الحاويات الفصل بين المسؤوليات من خلال تقسيم المهام والمسؤوليات بين المطورين وفرق عمليات تكنولوجيا المعلومات. يتحمل المطورون مسؤولية إنشاء التعليمات البرمجية للتطبيقات وتوابعها والحفاظ عليها، بينما تركز فرق عمليات تكنولوجيا المعلومات على نشر وإدارة الحاويات والبنية التحتية الأساسية.

تطوير أسرع للتطبيقات

تسهل الحاويات تطوير البرمجيات واختبارها وإدارتها وتوزيعها. يمكن دمج الحاويات بسهولة مع أنظمة CI/CD، مما يمكن أن يسرّع بشكل كبير من عملية تطوير البرمجيات وشحنها.

سهولة التحجيم

يمكن للتطبيقات في حاويات مع منصة تنسيق مثل Kubernetes أن تتوسع بسهولة عند الطلب. يتيح ذلك لشركتك استيعاب أعباء العمل العالية مع تقليل التكاليف.

حالات استخدام الحاويات

تحتوي تقنية الحاويات على الكثير من حالات الاستخدام للمطورين وكذلك لفرق عمليات تكنولوجيا المعلومات.

تطوير الحاويات-الأصلية

تطوير الحاويات الأصلية هو نهج تطوير البرمجيات الذي يستفيد من الحاويات كلبنة أساسية. في التطوير الأصلي للحاويات، يتم تجميع التطبيقات كحاويات وتشغيلها في بيئة حاويات. يمنحك نهج التطوير هذا جميع المزايا الرائعة التي تقدمها الحاويات.

التكامل المستمر والتسليم المستمر (CI/CD)

في خط أنابيب CI/CD، يتم استخدام الحاويات لحزم التطبيقات وتشغيل الاختبارات الآلية، مما يجعل من الممكن اختبار التطبيقات ونشرها بطريقة متسقة وقابلة للتكرار. يمكن إنشاء الحاويات واختبارها ونشرها بسهولة كجزء من خط أنابيب CI/CD، مما يقلل من مخاطر الأخطاء ويحسن الكفاءة الكلية لعملية تطوير البرمجيات.

الخدمات المصغرة

يمكن استخدام الحاويات لتطوير التطبيقات التي تتبع بنية الخدمات المصغرة. وباستخدام الحاويات، يمكنك بسهولة تقسيم تطبيقك المتجانس إلى مجموعة من الخدمات المترابطة بشكل فضفاض ودقيق والتي تعمل في حاويات مختلفة.

بيئة التنمية

تسهل الحاويات على فرق المطورين إعداد بيئات التطوير الخاصة بهم بسرعة. فهي توفر بيئات تطوير متسقة بغض النظر عن نظام التشغيل المضيف والمكتبات المضيفة.

عمليات الدُفعات

يمكن بسهولة وضع العمليات المجمعة في حاويات ونشرها على السحابة. يتم حزم كل مهمة كصورة حاوية فردية وتنفيذها كمثيل حاوية منفصلة. يتيح ذلك استخدام الموارد بكفاءة، حيث تعمل كل مهمة في بيئتها الخاصة ولا تتداخل مع المهام الأخرى.

الحاويات مقابل الآلات الافتراضية

الحاويات والأجهزة الافتراضية هما طريقتان مختلفتان للمحاكاة الافتراضية. على الرغم من وجود بعض أوجه التشابه، إلا أنهما مختلفان تمامًا.

الأجهزة الافتراضية (VMs) هي تجريد للأجهزة المادية. فهي تسمح لنا بتحويل خادم واحد إلى خوادم متعددة. لكل جهاز افتراضي نظام تشغيل خاص به وعادةً ما تتم إدارته بواسطة برنامج Hypervisor. تُعد الأجهزة الافتراضية مناسبة لتشغيل تطبيقات متعددة (على نفس الخادم)، والتطبيقات المتجانسة، والتطبيقات التي تتطلب درجة عالية من العزلة والأمان. عيبها هو أنها تميل إلى شغل مساحة كبيرة ويمكن أن تكون بطيئة جدًا في التشغيل.

من ناحية أخرى، تكون الحاويات افتراضية على مستوى نظام التشغيل. فهي تشغل مساحة أقل نظرًا لأنها تشترك في نواة Linux نفسها، وهي أكثر كفاءة، وتشغيلها أسرع، وقابلة للتطوير بدرجة كبيرة، ويمكنها التعامل مع المزيد من التطبيقات. تتم إدارة الحاويات بواسطة محرك حاويات. حالات الاستخدام الرئيسية لها على عكس الأجهزة الافتراضية هي الخدمات المصغرة والتطبيقات التي تحتاج إلى أن تكون محمولة وخفيفة الوزن وقابلة للتطوير.

من الممكن أيضًا الجمع بين الحاويات والأجهزة الافتراضية للحصول على مزايا كليهما.

Docker و Kubernetes

اثنتان من أكثر الأدوات شيوعًا للعمل مع الحاويات هما Docker و Kubernetes. دعونا نشرح كيفية عملهما وننظر إلى الاختلافات بينهما.

Docker هو مشروع مفتوح المصدر قائم على نظام لينكس يُستخدم لأتمتة نشر التطبيقات وإدارتها في حاويات خفيفة الوزن. وهذا يسمح للتطبيقات المعبأة في حاويات بالعمل بكفاءة في بيئات مختلفة. في هذه الأيام يمكن العثور على Docker في أي مكان تقريبًا من أجهزة لينكس إلى مزودي الخدمات السحابية الكبيرة وما إلى ذلك.

بدائل Docker الأكثر شيوعًا هي Podman وLXD وcontainerd.

Kubernetes (K8s) هو نظام مفتوح المصدر لتنسيق الحاويات لأتمتة نشر التطبيقات المعبأة في حاويات وتوسيع نطاقها وإدارتها. منذ إطلاقه في عام 2014، أصبح المعيار الفعلي لنشر وتشغيل التطبيقات المعبأة في حاويات في البيئات السحابية. تتضمن مزايا Kubernetes قابلية التوسع، والتوافر العالي، والعمليات الآلية، وتجريد البنية التحتية، ومراقبة الحالة الصحية.

تشمل منصات التنسيق الأخرى: AWS ECS و Nomad و Red Hat OpenShift.

إذن ما الفرق بين Docker و Kubernetes؟ حسنًا، بعبارات بسيطة، يسمح لنا Docker بتعبئة التطبيقات وتوزيعها داخل الحاويات، بينما يسهّل Kubernetes عمل حاويات متعددة في تناغم مع بعضها البعض.

تطوير تطبيق باستخدام البنية القائمة على الحاويات

في هذا القسم من البرنامج التعليمي، سننشئ واجهة برمجة تطبيقات REST بسيطة ونرسيها وننشرها في حاويات Back4app.

ما هي حاويات Back4app Containers؟

حاويات Back4app Containers هي منصة مجانية مفتوحة المصدر لنشر التطبيقات وتوسيع نطاقها على حاويات موزعة عالميًا في بنية تحتية سحابية.

يتيح لك التركيز على برنامجك وشحنه بشكل أسرع دون الحاجة إلى القلق بشأن DevOps. تتكامل المنصة بشكل وثيق مع GitHub، وتحتوي على نظام CI/CD مدمج، وتتيح لك تشغيل تطبيقك في دقائق!

لماذا نستخدم حاويات Back4app Containers؟

• يتكامل بشكل جيد مع GitHub
• عمليات النشر بدون تعطّل في الوقت المحدد لها
• سهلة الاستخدام وتتوفر بها فئة مجانية
• دعم عملاء ممتاز

مقدمة المشروع

سنقوم ببناء واجهة برمجة تطبيقات REST بسيطة ستكون بمثابة قائمة مشاهدة للأفلام. سيسمح تطبيق الويب بإجراء عمليات CRUD الأساسية مثل إضافة فيلم وحذف فيلم وما إلى ذلك. لإنشاء واجهة برمجة التطبيقات سنستخدم إطار عمل Flask. أخيرًا، سنقوم بتحويل المشروع إلى Docker وإظهار مدى سهولة نشره على حاويات Back4app.

المتطلبات الأساسية

• خبرة في إطار عمل فلاسك
• الفهم الأساسي ل Docker والحاويات
• القدرة على استخدام Git وGitHub

تطبيق الكود

ستتطلب منك الخطوات التالية تثبيت Python. إذا لم يكن لديك Python مثبتًا بعد، فقم بتنزيله.

تهيئة المشروع

أولاً، قم بإنشاء دليل مخصص لتطبيقك وانتقل إليه:

$ mkdir flask-watchlist
$ cd flask-watchlist

بعد ذلك، قم بإنشاء بيئة افتراضية جديدة وقم بتفعيلها:

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

بما أننا سنستخدم Flask كإطار عمل لنا، علينا تثبيته:

$ (venv) pip install Flask==2.2.2

قم بإنشاء app.py بالمحتويات التالية:

# app.py

from flask import Flask

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


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

يهيئ هذا الرمز Flask وينشئ نقطة نهاية بسيطة تُرجع رسالة.

قم بتشغيل الخادم باستخدام:

$ flask run

انتقل إلى http://localhost:5000/ وستظهر لك رسالة تقول مرحباً أيها العالم!

قاعدة البيانات

بالنسبة لقاعدة البيانات، سنستخدم SQLite. SQLite هو نظام مدمج لإدارة قواعد البيانات العلائقية بدون خادم. لتبسيط العمل مع قاعدة البيانات، سنقوم بتثبيت Flask-SQLAlchemy – وهو امتداد ل Flask يضيف دعم SQLAlchemy إلى تطبيقك.

انطلق وقم بتثبيته عن طريق تشغيله:

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

بعد ذلك، انتقل إلى أعلى app.py وقم بتغييره هكذا لتهيئة قاعدة البيانات:

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

لا تنسى الاستيراد:

from flask_sqlalchemy import SQLAlchemy

بعد ذلك، دعنا نحدد نماذج قاعدة البيانات الخاصة بنا.

بما أننا ننشئ تطبيقًا بسيطًا لقائمة مشاهدة الأفلام سنحتاج إلى نموذج واحد فقط. عرِّف نموذج الفيلم هكذا:

# 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

لتهيئة وتعبئة قاعدة البيانات الخاصة بنا سننشئ برنامج نصي بسيط من Python. انتقل إلى جذر مشروعك وأنشئ ملفًا جديدًا باسم init_db.py بالمحتويات التالية:

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

آخر ما علينا فعله هو تشغيل البرنامج النصي:

$ (venv) python init_db.py

يؤدي هذا إلى إنشاء قاعدة البيانات وجداول قاعدة البيانات وتعبئتها. سيتم وضع ملف قاعدة البيانات في مجلد المثيل.

نقاط نهاية واجهة برمجة التطبيقات (API)

سيحتوي تطبيق الويب الخاص بنا على نقاط النهاية التالية:

1. / إرجاع معلومات API الأساسية
2. يقوم /api/ بإرجاع قائمة الأفلام
3. /API/إنشاء/إضافة فيلم جديد إلى قائمة المشاهدة
4. /API/ / إرجاع تفاصيل فيلم معين
5. /API/Watch/ / يضع علامة على الفيلم كما شوهد

انطلق وحدد نقاط النهاية في الجزء السفلي من 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()

لا تنسى الواردات:

from datetime import datetime
from flask import request, jsonify

رائع، اكتمل تطبيقنا الآن بشكل أو بآخر. قم بتشغيل خادم التطوير:

$ (venv) flask run

اختبر ما إذا كان بإمكانك جلب قائمة الأفلام:

$ (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

خادم تطوير Flask غير مناسب للإنتاج، لذا دعنا نستبدله بـ Gunicorn. Gunicorn أو “يونيكورن الأخضر” هو خادم Python WSGI HTTP جاهز للإنتاج من نوع Python WSGI HTTP لنظام Unix.

قم بتثبيته عن طريق تشغيله:

$ (venv) pip install gunicorn==20.1.0

بعد أن يتم تثبيت الحزمة يمكنك بدء تشغيل خادم WSGI الخاص بك على النحو التالي:

$ (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

ضع في اعتبارك أن هذا الأمر يعمل فقط على أنظمة التشغيل المستندة إلى UNIX.

سيؤدي ذلك إلى بدء تشغيل عاملي Gunicorn وتعريض تطبيقك للإنترنت. للوصول إلى التطبيق افتح متصفح الويب المفضل لديك وانتقل إلى http://localhost:5000.

المتطلبات.txt

آخر شيء نحتاج إلى القيام به قبل إرساء تطبيقنا هو إنشاء ملف requirements.txt. يُستخدم ملف requirements.txt لتحديد تبعيات المشروع.

أسهل طريقة لتوليدها هي عن طريق الجري:

$ (venv) pip freeze > requirements.txt

تطبيق Dockerize

ستتطلب منك الخطوات التالية تثبيت Docker. أسهل طريقة لتثبيت Docker هي تنزيل Docker Desktop.

للتحقق من تثبيت Docker لديك قم بتشغيل Docker:

$ docker --version

Docker version 20.10.22, build 3a2c30b

Dockerfile

لإرساء تطبيقنا سنستخدم ملف Dockerfile. ملف Dockerfile هو ملف نصي عادي يسمح لنا بتعريف الصورة الأساسية والبيئة والمتغيرات البيئية والأوامر وإعدادات الشبكات ووحدات التخزين وما إلى ذلك.

أنشئ ملف Dockerfile في جذر مشروعك بالمحتويات التالية:

# 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. استخدمنا python:3.10-alpine كصورة أساسية.
2. تعيين PYTHONDONTWONTWRITEBYTECODE إلى 1 يجعل Python لا يكتب ملفات .pyc على القرص.
3. يضمن ضبط PYTHONUNBUFFERED على 1 إرسال تدفقات مخرجات Python مباشرةً إلى الطرفية.

لمزيد من المعلومات حول كتابة ملفات Dockerfiles ألق نظرة على مرجع Dockerfile.

.dockerignore

قبل أن يقوم Docker ببناء صورة يبحث عن ملف .d ockerignore . يتيح لنا ملف .dockerignore تحديد الملفات التي لا نريد تضمينها في الصورة. يمكن أن يقلل هذا من حجم الصورة بشكل كبير. يعمل بشكل مشابه لملف .gitignore.

أنشئ ملف .dockerignore في جذر المشروع بالمحتويات التالية :

# .dockerignore

.git/
instance/
__pycache__/
.idea/

تأكد من إضافة أي دلائل أو ملفات إضافية ترغب في استبعادها.

إنشاء الصورة وتشغيلها

للمضي قدمًا، لننشئ صورة Docker ونضع علامة عليها.

$ 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 

إذا قمت بإدراج الصور يجب أن ترى صورتنا الجديدة:

$ docker images

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

وأخيراً، استخدم الصورة لتجهيز حاوية Docker جديدة:

$ 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

يمكنك استخدام -d لبدء تشغيل حاوية Docker في الوضع المنفصل. وهذا يعني أن الحاوية تعمل في خلفية جهازك الطرفي ولا تتلقى مدخلات أو تعرض مخرجات.

أحسنت، تطبيقك يعمل الآن في حاوية! انتقل إلى http://localhost:5000 وستحصل على الرد التالي:

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

GitHub

لنشر التطبيق على Back4app Containers، سيكون عليك تحميل شفرتك المصدرية إلى مستودع GitHub. امض قدمًا وأنشئ مستودعًا جديدًا على GitHub، وأضف جهاز التحكم عن بُعد، وأضف .gitignore، وارفع شفرتك البرمجية. بمجرد أن تكون شفرتك على GitHub انتقل إلى الخطوة التالية.

نشر التطبيق في حاويات Back4app Containers

ستتطلب الخطوات التالية أن يكون لديك حساب Back4app. إذا كان لديك حساب بالفعل قم بتسجيل الدخول وإلا فقم بالتسجيل للحصول على حساب مجاني.

للعمل مع Back4app نحتاج أولاً إلى إنشاء تطبيق. عند تسجيل الدخول إلى لوحة التحكم الخاصة بك سترى قائمة تطبيقاتك. انقر على “إنشاء تطبيق جديد” لإنشاء تطبيق جديد.

بعد ذلك، حدد “الحاويات كخدمة”.

إذا لم تكن قد قمت بالفعل بتوصيل GitHub الخاص بك ب Back4app واستيراد المستودعات التي ترغب في نشرها. بمجرد توصيل GitHub الخاص بك سيتم عرض مستودعاتك في الجدول.

اختر المستودع الذي ترغب في نشره بالنقر على “تحديد”.

بعد ذلك، سيطلب منك Back4app تهيئة البيئة. اختر اسمًا للتطبيق، سأختار قائمة مراقبة ال Flask. لا تتردد في ترك كل شيء آخر كما هو افتراضي.

وأخيراً، انقر على “إنشاء تطبيق” لإنشاء التطبيق تلقائياً ونشره.

ستتم إعادة توجيهك بعد ذلك إلى تفاصيل تطبيقك حيث يمكنك رؤية سجلات النشر.

انتظر بضع دقائق حتى يتم نشر التطبيق وفويلا! أصبح تطبيقك الآن متاحًا على حاويات Back4app. لرؤية تطبيقك قيد التشغيل انقر فوق عنوان URL الأخضر المعروض على اليسار.

الخاتمة

لقد شرحنا في هذه المقالة ما هي الحاويات وفوائدها وشرحنا كيف يمكنك تنفيذ الحاويات في سير عملك. الآن يجب أن تكون قادرًا على إنشاء واجهة برمجة تطبيقات REST API البسيطة الخاصة بك، وإرساءها ونشرها في حاويات Back4app.

احصل على الكود المصدري النهائي من مستودع GitHub.

الخطوات المستقبلية

1. لا يجب عليك تخزين قاعدة البيانات في صورتك. في الوقت الحالي ستؤدي كل عملية إعادة نشر إلى إعادة تعيين قاعدة البيانات. فكر في التبديل إلى مثيل PostgreSQL أو MySQL مُدار.
2. تعرف على البنيات متعددة المراحل لتحسين ملفات Dockerfiles الخاصة بك.
3. اقرأ مقالة نشر حاويات Docker Containers للحصول على برنامج تعليمي مفصل خطوة بخطوة

الأسئلة الشائعة