Bulut bilişimde konteynerler nedir?

Docker 2013 yılında sahneye çıktığından beri konteynerlerin popülaritesi hızla artıyor. Pek çok şirket, yazılımlarını kolayca dağıtmalarına, yönetmelerine ve ölçeklendirmelerine olanak tanıdığı için konteynerleri iş akışlarına entegre etmiş durumda.

Bu makalede, bulut bilişimde konteynerlerin ne olduğunu açıklayacağız. Konteyner kullanmanın faydalarından, kullanım alanlarından bahsedecek, onları sanal makinelerle karşılaştıracak ve Docker ile Kubernetes’i inceleyeceğiz. Son olarak, bir web uygulamasını Back4app Containers ‘a nasıl kodlayacağınızı, docker’layacağınızı ve dağıtacağınızı öğreteceğiz – tamamen ücretsiz!

Konteyner Tanımı

Konteyner, bir uygulamayı çalıştırmak için gereken her şeyi içeren bağımsız bir yürütülebilir pakettir: kod, çalışma zamanı, kütüphaneler, ortam değişkenleri ve yapılandırma dosyaları. Konteynerli uygulamalarla ilgili harika olan şey, yerel geliştirme ortamınızdan genel bulutlara kadar her yerde çalışabilmeleridir. Konteynerler küçük boyutludur, verimlidir ve etkili izolasyon sağlar.

Konteyner kullanmanın faydaları

Konteyner kullanmanın çeşitli faydaları vardır. Şimdi bunlardan bazılarına göz atalım.

Verimlilik

Konteynerler, bir işletim sistemi görüntüsü içermedikleri için geleneksel sunuculara veya sanal makinelere göre daha az sistem kaynağı gerektirir. Bu da onları son derece verimli, küçük boyutlu (genellikle MB cinsinden ölçülür) hale getirir ve tek bir sunucuda önemli sayıda uygulama çalıştırmanıza olanak tanır.

Uygulama İzolasyonu

Konteynerler uygulamayı ve bağımlılıklarını ana sistemden izole eder. Aynı zamanda, işletim sistemi çekirdeğini ve CPU, bellek, depolama ve ağ gibi sistem kaynaklarını paylaşabilirler.

Taşınabilirlik

Konteynerli yazılım, konteyner motorunun kurulu olduğu hemen her makinede aynı şekilde çalışabilir ve davranabilir. Bu, uygulamaları farklı ortamlar arasında dağıtmayı ve taşımayı kolaylaştırır ve “benim makinemde çalışıyor” sorununu ortadan kaldırır.

Sorumlulukların Ayrılması

Konteynerler, görevleri ve sorumlulukları geliştiriciler ve BT operasyon ekipleri arasında paylaştırarak sorumlulukların ayrılmasını sağlar. Geliştiriciler uygulama kodunu ve bağımlılıklarını oluşturmaktan ve sürdürmekten sorumluyken, BT operasyon ekipleri konteynerleri ve temel altyapıyı dağıtmaya ve yönetmeye odaklanır.

Daha Hızlı Uygulama Geliştirme

Konteynerleştirme yazılım geliştirmeyi, test etmeyi, yönetmeyi ve dağıtmayı kolaylaştırır. Konteynerler CI/CD sistemleri ile kolayca entegre edilebilir, bu da yazılım geliştirme ve sevkiyat sürecini büyük ölçüde hızlandırabilir.

Kolay Ölçeklendirme

Kubernetes gibi bir orkestrasyon platformuyla birlikte konteynerli uygulamalar talep üzerine kolayca ölçeklendirilebilir. Bu, işletmenizin maliyetleri en aza indirirken yüksek iş yüklerini barındırmasına olanak tanır.

Konteynerler Kullanım Örnekleri

Konteyner teknolojisi, geliştiricilerin yanı sıra BT operasyon ekipleri için de birçok kullanım alanına sahiptir.

Konteyner-Yerel Geliştirme

Konteyner-yerel geliştirme, konteynerleri birincil yapı taşı olarak kullanan bir yazılım geliştirme yaklaşımıdır. Konteyner-yerel geliştirmede uygulamalar konteyner olarak paketlenir ve konteynerleştirilmiş bir ortamda çalıştırılır. Bu geliştirme yaklaşımı size konteynerlerin sunduğu tüm harika avantajları sunar.

Sürekli Entegrasyon ve Sürekli Teslimat (CI/CD)

Bir CI/CD ardışık düzeninde konteynerler uygulamaları paketlemek ve otomatik testleri çalıştırmak için kullanılır, böylece uygulamaların tutarlı ve tekrarlanabilir bir şekilde test edilmesi ve dağıtılması mümkün olur. Kapsayıcılar CI/CD ardışık düzeninin bir parçası olarak kolayca oluşturulabilir, test edilebilir ve dağıtılabilir, bu da hata riskini azaltır ve yazılım geliştirme sürecinin genel verimliliğini artırır.

Mikro Hizmetler

Kapsayıcılar, mikro hizmet mimarisini takip eden uygulamalar geliştirmek için kullanılabilir. Kapsayıcılarla, monolitik uygulamanızı farklı kapsayıcılarda çalışan gevşek bir şekilde bağlanmış, ince taneli hizmetlerden oluşan bir koleksiyona kolayca bölebilirsiniz.

Geliştirme Ortamı

Konteynerler, geliştirici ekiplerinin geliştirme ortamlarını hızlı bir şekilde kurmalarını kolaylaştırır. Ana bilgisayar işletim sistemi ve ana bilgisayar kütüphanelerinden bağımsız olarak tutarlı geliştirme ortamları sağlarlar.

Toplu İşlem Süreçleri

Toplu işlemler kolayca konteynerleştirilebilir ve buluta dağıtılabilir. Her görev ayrı bir konteyner imajı olarak paketlenir ve ayrı bir konteyner örneği olarak yürütülür. Bu, her görev kendi ortamında çalıştığı ve diğer görevlerle etkileşime girmediği için verimli kaynak kullanımına olanak tanır.

Konteynerler ve Sanal Makineler

Konteynerler ve sanal makineler sanallaştırmaya iki farklı yaklaşımdır. Bazı benzerlikleri olsa da oldukça farklıdırlar.

Sanal makineler (VM’ler) fiziksel donanımın bir soyutlamasıdır. Bir sunucuyu birden fazla sunucuya dönüştürmemizi sağlarlar. Sanal makinelerin her biri kendi işletim sistemine sahiptir ve genellikle bir hipervizör tarafından yönetilir. VM’ler birden fazla uygulamayı (aynı sunucuda), monolitik uygulamaları ve yüksek derecede izolasyon ve güvenlik gerektiren uygulamaları çalıştırmak için uygundur. Dezavantajları ise çok fazla yer kaplamaları ve açılışlarının oldukça yavaş olabilmesidir.

Öte yandan konteynerler işletim sistemi düzeyinde sanallaştırılmıştır. Aynı Linux çekirdeğini paylaştıkları için daha az yer kaplarlar, daha verimlidirler, daha hızlı açılırlar, yüksek oranda ölçeklenebilirler ve daha fazla uygulamayı işleyebilirler. Konteynerler bir Konteyner Motoru tarafından yönetilir. Sanal makinelerin aksine ana kullanım alanları mikro hizmetler ve taşınabilir, hafif ve ölçeklenebilir olması gereken uygulamalardır.

Her ikisinin de avantajlarından yararlanmak için konteynerleri ve VM’leri birleştirmek de mümkündür.

Docker ve Kubernetes

Konteynerlerle çalışmak için en popüler araçlardan ikisi Docker ve Kubernetes’tir. Nasıl çalıştıklarını açıklayalım ve farklılıklarına bakalım.

Docker, uygulamaların hafif konteynerlerde dağıtımını ve yönetimini otomatikleştirmek için kullanılan Linux tabanlı açık kaynaklı bir projedir. Bu, konteynerli uygulamaların farklı ortamlarda verimli bir şekilde çalışmasını sağlar. Bu günlerde Docker, Linux makinelerinden büyük bulut sağlayıcılarına kadar hemen hemen her yerde bulunabilir.

En popüler Docker alternatifleri Podman, LXD ve containerd‘dir.

Kubernetes (K8s), konteynerli uygulamaların dağıtımını, ölçeklendirilmesini ve yönetimini otomatikleştirmeye yönelik açık kaynaklı bir konteyner düzenleme sistemidir. 2014’te piyasaya sürülmesinden bu yana, bulut ortamlarında konteynerli uygulamaları dağıtmak ve çalıştırmak için fiili standart haline gelmiştir. Kubernetes’in faydaları arasında ölçeklenebilirlik, yüksek kullanılabilirlik, otomatik işlemler, altyapı soyutlaması ve sağlık izleme yer alır.

Diğer orkestrasyon platformları şunlardır: AWS ECS, Nomad ve Red Hat OpenShift.

Peki Docker ve Kubernetes arasındaki fark nedir? Basit bir ifadeyle Docker, uygulamaları konteynerler içinde paketlememizi ve dağıtmamızı sağlarken, Kubernetes birden fazla konteynerin birbiriyle uyum içinde çalışmasını kolaylaştırır.

Konteyner Tabanlı Mimari Kullanarak Uygulama Geliştirme

Eğitimin bu bölümünde, Back4app Containers‘a basit bir REST API oluşturacak, dockerize edecek ve dağıtacağız.

Back4app Konteynerleri Nedir?

Back4app Containers, bir bulut altyapısında küresel olarak dağıtılmış kapsayıcılarda uygulamaları dağıtmak ve ölçeklendirmek için ücretsiz bir açık kaynak platformudur.

DevOps hakkında endişelenmenize gerek kalmadan yazılımınıza odaklanmanıza ve daha hızlı göndermenize olanak tanır. Platform GitHub ile yakından entegredir, yerleşik bir CI/CD sistemine sahiptir ve uygulamanızı dakikalar içinde hazırlayıp çalıştırmanıza olanak tanır!

Neden Back4app Containers kullanılmalı?

• GitHub ile iyi entegre olur
• Sıfır kesinti süreli dağıtımlar
• Kullanımı kolay ve ücretsiz bir katmanı var
• Mükemmel müşteri desteği

Proje Tanıtımı

Film izleme listesi olarak hizmet verecek basit bir REST API’si oluşturacağız. Web uygulaması film ekleme, film silme gibi temel CRUD işlemlerine izin verecek. API’yi oluşturmak için Flask çatısını kullanacağız. Son olarak, projeyi Dockerize edeceğiz ve Back4app Containers’a dağıtmanın ne kadar kolay olduğunu göstereceğiz.

Ön Koşullar

• Flask framework ile deneyim
• Docker ve konteynerler hakkında temel bilgi
• Git ve GitHub kullanabilme

Kod Uygulaması

Aşağıdaki adımlar Python’un yüklü olmasını gerektirecektir. Eğer henüz Python yüklü değilse, devam edin ve indirin.

Proje başlatma

İlk olarak, uygulamanız için özel bir dizin oluşturun ve bu dizine gidin:

$ mkdir flask-watchlist
$ cd flask-watchlist

Ardından, yeni bir sanal ortam oluşturun ve etkinleştirin:

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

Çerçeve olarak Flask kullanacağımız için onu yüklememiz gerekiyor:

$ (venv) pip install Flask==2.2.2

Aşağıdaki içeriklerle app.py dosyasını oluşturun:

# app.py

from flask import Flask

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


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

Bu kod Flask’ı başlatır ve bir mesaj döndüren basit bir uç nokta oluşturur.

Sunucuyu şu şekilde çalıştırın:

$ flask run

http://localhost:5000/ adresine gidin ve Merhaba dünya! yazan bir mesaj görmelisiniz.

Veritabanı

Veritabanı için SQLite kullanacağız. SQLite gömülü, sunucusuz bir ilişkisel veritabanı yönetim sistemidir. Veritabanı ile çalışmayı kolaylaştırmak için Flask-SQLAlchemy ‘yi kuracağız – Flask için uygulamanıza SQLAlchemy desteği ekleyen bir uzantı.

Devam edin ve çalıştırarak yükleyin:

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

Ardından, app.py dosyasının en üstüne gidin ve veritabanını başlatmak için şu şekilde değiştirin:

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

İthalatı unutmayın:

from flask_sqlalchemy import SQLAlchemy

Ardından, veritabanı modellerimizi tanımlayalım.

Basit bir film izleme listesi uygulaması oluşturduğumuz için yalnızca bir modele ihtiyacımız olacak. Film modelini şu şekilde tanımlayın:

# 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

Veritabanımızı başlatmak ve doldurmak için basit bir Python betiği oluşturacağız. Proje kök dizininize gidin ve init_db.py adında aşağıdaki içeriğe sahip yeni bir dosya oluşturun:

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

Yapmamız gereken son şey betiği çalıştırmak:

$ (venv) python init_db.py

Bu işlem veritabanını, veritabanı tablolarını oluşturur ve bunları doldurur. Veritabanı dosyası örnek klasörüne yerleştirilecektir.

API uç noktaları

Web uygulamamız aşağıdaki uç noktalara sahip olacaktır:

1. / temel API bilgilerini döndürür
2. /api/ filmlerin listesini döndürür
3. /api/create/ izleme listesine yeni bir film ekler
4. /api/ / belirli bir filmin ayrıntılarını döndürür
5. /api/watch/ / filmi görüldü olarak işaretler

Devam edin ve app.py dosyasının altındaki uç noktaları tanımlayın:

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

İthalleri unutmayın:

from datetime import datetime
from flask import request, jsonify

Harika, uygulamamız artık aşağı yukarı tamamlandı. Geliştirme sunucusunu çalıştırın:

$ (venv) flask run

Film listesini getirip getiremeyeceğinizi test edin:

$ (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 geliştirme sunucusu üretim için uygun değildir, bu yüzden onu Gunicorn ile değiştirelim. Gunicorn veya “Green Unicorn” Unix için üretime hazır bir Python WSGI HTTP Sunucusudur.

Çalıştırarak yükleyin:

$ (venv) pip install gunicorn==20.1.0

Paket kurulduktan sonra WSGI sunucunuzu şu şekilde başlatabilirsiniz:

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

Bu komutun yalnızca UNIX tabanlı işletim sistemlerinde çalıştığını unutmayın.

Bu, iki Gunicorn çalışanını başlatacak ve uygulamanızı internete açacaktır. Uygulamaya erişmek için favori web tarayıcınızı açın ve http://localhost:5000 adresine gidin.

gereksinimler.txt

Uygulamamızı Docker’lamadan önce yapmamız gereken son şey bir requirements.txt dosyası oluşturmaktır. requirements.txt dosyası projenin bağımlılıklarını belirtmek için kullanılır.

Bunu oluşturmanın en kolay yolu çalıştırmaktır:

$ (venv) pip freeze > requirements.txt

Dockerize Uygulaması

Aşağıdaki adımlar Docker’ı yüklemiş olmanızı gerektirecektir. Docker’ı yüklemenin en kolay yolu Docker Desktop‘ı indirmektir.

Docker’ın kurulu olduğunu doğrulamak için çalıştırın:

$ docker --version

Docker version 20.10.22, build 3a2c30b

Dockerfile

Uygulamamızı dockerize etmek için bir Dockerfile kullanacağız. Dockerfile, temel imajı, ortamı, çevresel değişkenleri, komutları, ağ ayarlarını, birimleri vb. tanımlamamıza olanak tanıyan düz bir metin dosyasıdır.

Proje kök dizininizde aşağıdaki içeriğe sahip bir Dockerfile oluşturun:

# 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. Temel görüntü olarak python:3.10-alpine kullandık.
2. PYTHONDONTWRITEBYTECODE değerini 1 olarak ayarlamak Python’un artık .pyc dosyalarını diske yazmamasını sağlar.
3. PYTHONUNBUFFERED değerinin 1 olarak ayarlanması Python çıktı akışlarının doğrudan terminale gönderilmesini sağlar.

Dockerfile yazma hakkında daha fazla bilgi için Dockerfile referansına göz atın.

.dockerignore

Docker bir imaj oluşturmadan önce bir .dockerignore dosyası arar. Bir .dockerignore dosyası, hangi dosyaların görüntüye dahil edilmesini istemediğimizi tanımlamamızı sağlar. Bu, imaj boyutunu büyük ölçüde azaltabilir. .gitignore dosyasına benzer şekilde çalışır.

Proje kök dizininde aşağıdaki içeriğe sahip bir .dockerignore dosyası oluşturun:

# .dockerignore

.git/
instance/
__pycache__/
.idea/

Hariç tutmak istediğiniz ek dizinleri veya dosyaları eklediğinizden emin olun.

Görüntüyü oluşturma ve çalıştırma

Devam edelim, Docker imajımızı oluşturalım ve etiketleyelim.

$ 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 

Resimleri listelerseniz yeni resmimizi görmeniz gerekir:

$ docker images

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

Son olarak, yeni bir Docker konteyneri oluşturmak için görüntüyü kullanın:

$ 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

Docker konteynerini ayrılmış modda başlatmak için -d komutunu kullanabilirsiniz. Bu, konteynerin terminalinizin arka planında çalıştığı ve girdi almadığı veya çıktı görüntülemediği anlamına gelir.

Aferin, uygulamanız artık bir konteyner içinde çalışıyor! http://localhost:5000 adresine gidin ve aşağıdaki yanıtı almalısınız:

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

GitHub

Uygulamayı Back4app Containers’a dağıtmak için kaynak kodunuzu bir GitHub deposuna yüklemeniz gerekir. Devam edin ve GitHub’da yeni bir depo oluşturun, uzaktan kumandayı ekleyin, .gitignore ekleyin ve kodunuzu işleyin. Kodunuz GitHub’a yüklendikten sonra bir sonraki adıma geçin.

Uygulamayı Back4app Konteynerlerine Dağıtın

Aşağıdaki adımlar bir Back4app hesabınızın olmasını gerektirecektir. Zaten hesabınız varsa giriş yapın, yoksa devam edin ve ücretsiz hesap için kaydolun.

Back4app ile çalışmak için öncelikle bir uygulama oluşturmamız gerekiyor. Kontrol panelinize giriş yaptığınızda uygulamalarınızın listesini göreceksiniz. Yeni bir uygulama oluşturmak için “Yeni bir uygulama oluştur” seçeneğine tıklayın.

Ardından, “Containers as a Service “i seçin.

Henüz yapmadıysanız, devam edin ve GitHub’ınızı Back4app’e bağlayın ve dağıtmak istediğiniz depoları içe aktarın. GitHub’ınız bağlandıktan sonra depolarınız tabloda görüntülenecektir.

“Seç “e tıklayarak dağıtmak istediğiniz depoyu seçin.

Daha sonra, Back4app sizden ortamı yapılandırmanızı isteyecek. Bir uygulama adı seçin, ben flask-watchlist ile gideceğim. Diğer her şeyi varsayılan olarak bırakmaktan çekinmeyin.

Son olarak, uygulamayı otomatik olarak oluşturmak ve dağıtmak için “Uygulama Oluştur “a tıklayın.

Daha sonra dağıtım günlüklerini görebileceğiniz uygulama ayrıntılarınıza yönlendirileceksiniz.

Uygulamanın dağıtılması için birkaç dakika bekleyin ve işte! Uygulamanız artık Back4app Containers üzerinde yayında. Uygulamanızı çalışırken görmek için sol tarafta görüntülenen yeşil URL’ye tıklayın.

Sonuç

Makale boyunca konteynerlerin ne olduğunu, faydalarını açıkladık ve konteynerleri iş akışınıza nasıl uygulayabileceğinizi gösterdik. Şimdiye kadar kendi basit REST API’nizi oluşturabilmeli, dockerize edebilmeli ve Back4app Containers’a dağıtabilmelisiniz.

GitHub deposundan nihai kaynak kodunu alın.

Gelecek adımlar

1. Veritabanını görüntünüzde saklamamalısınız. Şu anda her yeniden dağıtım veritabanını sıfırlayacaktır. Yönetilen bir PostgreSQL veya MySQL örneğine geçmeyi düşünün.
2. Docker dosyalarınızı optimize etmek için çok aşamalı derlemeler hakkında bilgi edinin.
3. Adım adım eğitim için Docker Konteynerlerini Dağıt ma makalesini okuyun

SSS