Flask Uygulamasını Docker ile Ubuntu 20.04 Üzerinde Oluşturma ve Dağıtma Rehberi

Flask Uygulamasını Docker ile Ubuntu 20.04 Üzerinde Oluşturma ve Dağıtma Rehberi

Giriş

Günümüzün hızla değişen yazılım dünyasında, uygulamaları tutarlı ve güvenilir bir şekilde dağıtmak ve yönetmek, geliştiriciler ve operasyon ekipleri için hayati önem taşımaktadır. Flask gibi hafif ve esnek bir Python web çatısı ile Docker gibi güçlü bir konteynerizasyon platformunun birleşimi, bu zorlukların üstesinden gelmek için mükemmel bir çözüm sunar. Bu makalede, bir Flask uygulamasını Ubuntu 20.04 işletim sistemi üzerinde Docker kullanarak nasıl oluşturacağımızı, konteynerize edeceğimizi ve dağıtacağımızı adım adım ele alacağız. Amacımız, geliştirme ortamından üretim ortamına kadar tutarlı bir deneyim sağlamak ve uygulama dağıtım süreçlerini basitleştirmektir.

Flask, Python tabanlı minimalist bir mikro web çatısıdır. Hızlı prototipleme ve küçük ila orta ölçekli uygulamalar için idealdir. Docker ise, uygulamaları ve bağımlılıklarını izole edilmiş “konteynerler” içinde paketlemeye olanak tanıyan bir platformdur. Bu konteynerler, farklı ortamlarda (geliştirme, test, üretim) tutarlı bir şekilde çalışmayı garanti eder. Ubuntu 20.04 ise, sunucu tarafında yaygın olarak kullanılan sağlam ve güvenilir bir Linux dağıtımıdır. Bu üç teknolojinin birleşimi, modern web uygulamaları geliştirmek ve dağıtmak için güçlü ve verimli bir ekosistem yaratır.

Bu rehberin sonunda, kendi Flask uygulamanızı Docker kullanarak bir Ubuntu 20.04 sunucusunda başarıyla çalıştırabilecek ve temel dağıtım prensiplerini anlamış olacaksınız.

Ön Gereksinimler

Bu rehberi takip edebilmek için aşağıdaki temel bilgilere ve araçlara sahip olmanız gerekmektedir:

• Ubuntu 20.04 işletim sistemi kurulu bir sunucu veya sanal makine.
• Temel Linux komut satırı bilgisi.
• sudo yetkisine sahip bir kullanıcı hesabı.
• İnternet bağlantısı.
• Flask ve Python hakkında temel bilgi (uygulama geliştirme kısmı için).

Ortam Kurulumu: Docker ve Docker Compose’u Yükleme

Flask uygulamamızı konteynerize etmeden önce, Ubuntu 20.04 sistemimize Docker ve Docker Compose’u kurmamız gerekiyor.

Sistemi Güncelleme

İlk adım olarak, sistem paket listesini güncelleyelim ve mevcut paketleri yükseltelim:

sudo apt update
sudo apt upgrade -y

Docker Kurulumu

Docker Engine’i kurmak için resmi Docker deposunu kullanacağız. Bu, en güncel sürümü edinmemizi ve gelecekte kolayca güncelleme yapmamızı sağlar.

1. Gerekli Paketleri Kurma:
Docker’ın HTTPS üzerinden depo kullanabilmesi için bazı ön koşul paketleri yüklememiz gerekiyor:

sudo apt install apt-transport-https ca-certificates curl gnupg-agent software-properties-common -y

2. Docker’ın Resmi GPG Anahtarını Ekleme:
Docker’ın resmi GPG anahtarını sistemimize ekleyerek indirilen paketlerin doğruluğunu sağlamış oluruz:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

3. Docker Deposunu Ekleme:
Şimdi Docker deposunu APT kaynaklarımıza ekleyebiliriz:

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

4. Docker Engine’i Kurma:
Depoyu ekledikten sonra, paket listesini tekrar güncelleyip Docker Engine’i kurabiliriz:

sudo apt update
    sudo apt install docker-ce docker-ce-cli containerd.io -y

5. Docker Kurulumunu Doğrulama:
Docker’ın doğru bir şekilde kurulup kurulmadığını test etmek için basit bir hello-world konteyneri çalıştırabiliriz:

sudo docker run hello-world

Bu komut, Docker’ın çalıştığını ve doğru şekilde yüklendiğini gösteren bir mesaj çıktısı vermelidir.

6. Docker’ı Root Olmadan Kullanma:
Varsayılan olarak, Docker komutlarını çalıştırmak için sudo kullanmanız gerekir. Kullanıcınızı docker grubuna ekleyerek bu gereksinimi ortadan kaldırabilirsiniz:

sudo usermod -aG docker $USER

Bu komutu çalıştırdıktan sonra, değişikliğin etkili olması için oturumu kapatıp tekrar açmanız veya sistemi yeniden başlatmanız gerekebilir.

newgrp docker # Oturumu yeniden başlatmadan test etmek için

Docker Compose Kurulumu

Docker Compose, çok konteynerli Docker uygulamalarını tanımlamak ve çalıştırmak için bir araçtır. Uygulamamız birden fazla servis (örneğin, Flask uygulaması, veritabanı, Nginx) içerecekse bu çok kullanışlıdır.

1. Docker Compose’u İndirme:
Docker Compose’un en son kararlı sürümünü GitHub deposundan indireceğiz. Lütfen komut içindeki sürüm numarasını (örneğin, v2.24.5) en güncel sürümle değiştirin. En güncel sürümü https://github.com/docker/compose/releases adresinden kontrol edebilirsiniz.

sudo curl -L "https://github.com/docker/compose/releases/download/v2.24.5/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

2. Yürütülebilir İzinleri Verme:
İndirilen dosyaya yürütülebilir izinler vermemiz gerekiyor:

sudo chmod +x /usr/local/bin/docker-compose

3. Docker Compose Kurulumunu Doğrulama:
Kurulumun başarılı olup olmadığını kontrol etmek için sürüm numarasını sorgulayabiliriz:

docker-compose --version

Bu komut, yüklü Docker Compose sürümünü göstermelidir.

Flask Uygulamasını Geliştirme

Şimdi basit bir Flask uygulaması oluşturalım. Bu uygulama, Docker konteyneri içinde çalışacak ve web tarayıcısından erişilebilir olacak.

Proje Yapısı

Projemiz için aşağıdaki gibi basit bir dizin yapısı oluşturalım:

flask-docker-app/
├── app/
│   └── app.py
└── requirements.txt

1. Proje Dizini Oluşturma:

mkdir flask-docker-app
    cd flask-docker-app
    mkdir app

2. Flask Uygulaması Oluşturma (app/app.py):
app/app.py dosyasını oluşturun ve içine aşağıdaki kodu ekleyin:

# app/app.py
    from flask import Flask

    app = Flask(__name__)

    @app.route('/')
    def hello():
        return "Merhaba, Docker ve Flask ile Dünya!"

    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=5000)

Bu basit uygulama, kök URL’ye (/) gelen isteklerde “Merhaba, Docker ve Flask ile Dünya!” mesajını döndürür. host='0.0.0.0' kullanmak önemlidir, çünkü bu, uygulamanın konteyner içinden dış dünyaya erişilebilir olmasını sağlar.

3. Bağımlılıklar Dosyası Oluşturma (requirements.txt):
requirements.txt dosyasını oluşturun ve içine uygulamanın bağımlılıklarını ekleyin:

# requirements.txt
    Flask==2.3.3
    gunicorn==21.2.0

Burada Flask uygulamanın kendisi için, gunicorn ise üretim ortamında Flask uygulamasını çalıştırmak için kullanılan bir WSGI (Web Server Gateway Interface) sunucusudur. Flask’ın dahili geliştirme sunucusu üretim için uygun değildir.

Uygulamayı Yerel Olarak Test Etme (Opsiyonel)

Docker’a geçmeden önce uygulamanın yerel olarak çalıştığından emin olmak isteyebilirsiniz.

# Sanal ortam oluşturma ve etkinleştirme
python3 -m venv venv
source venv/bin/activate

Bağımlılıkları yükleme
pip install -r requirements.txt

Uygulamayı çalıştırma (gunicorn ile)
gunicorn -w 4 app.app:app -b 0.0.0.0:5000

Tarayıcınızda http://localhost:5000 adresine giderek uygulamanın çalıştığını görebilirsiniz. İşiniz bittiğinde Ctrl+C ile sunucuyu durdurabilir ve deactivate ile sanal ortamdan çıkabilirsiniz.

Flask Uygulamasını Docker ile Konteynerize Etme

Şimdi Flask uygulamamızı bir Docker konteyneri içine yerleştireceğiz. Bunun için bir Dockerfile oluşturmamız gerekiyor.

Dockerfile Oluşturma

flask-docker-app dizininin kökünde Dockerfile adında bir dosya oluşturun ve içine aşağıdaki içeriği ekleyin:

# Dockerfile
Python'ın hafif bir sürümünü temel imaj olarak kullanın
FROM python:3.9-slim-buster

Çalışma dizinini ayarlayın
WORKDIR /app

Bağımlılıklar dosyasını kopyalayın
COPY requirements.txt .

Bağımlılıkları kurun
--no-cache-dir: pip önbelleğini kullanmaz, imaj boyutunu azaltır
-r: requirements.txt dosyasından yükler
RUN pip install --no-cache-dir -r requirements.txt

Uygulama kodunu kopyalayın
COPY app/ .

Uygulamanın 5000 portunda dinleyeceğini belirtin
EXPOSE 5000

Uygulamayı Gunicorn ile başlatma komutu
-w 4: 4 adet worker (işçi) süreci kullanır
app:app: app dizinindeki app.py dosyasındaki 'app' Flask uygulamasını belirtir
-b 0.0.0.0:5000: Tüm ağ arayüzlerinde 5000 portunda dinler
CMD ["gunicorn", "-w", "4", "app:app", "-b", "0.0.0.0:5000"]

Bu Dockerfile adımları şu anlama gelir:

• FROM python:3.9-slim-buster: Python 3.9’un Debian Buster tabanlı, hafif bir sürümünü temel imaj olarak kullanır. Bu, nihai imaj boyutunu küçültmeye yardımcı olur.
• WORKDIR /app: Konteyner içinde /app dizinini çalışma dizini olarak ayarlar. Sonraki tüm komutlar bu dizin içinde çalışır.
• COPY requirements.txt .: requirements.txt dosyasını yerel dizinden konteynerin /app dizinine kopyalar.
• RUN pip install --no-cache-dir -r requirements.txt: requirements.txt dosyasındaki tüm Python bağımlılıklarını kurar. --no-cache-dir seçeneği, önbelleği temizleyerek imaj boyutunu optimize eder.
• COPY app/ .: app/ dizini içindeki tüm uygulama kodunu konteynerin /app dizinine kopyalar.
• EXPOSE 5000: Konteynerin 5000 numaralı portu dinleyeceğini bildirir. Bu, dışarıdan erişim için bir bildirimdir, ancak doğrudan portu açmaz.
• CMD ["gunicorn", "-w", "4", "app:app", "-b", "0.0.0.0:5000"]: Konteyner başlatıldığında çalışacak komutu tanımlar. Gunicorn, Flask uygulamasını 4 worker ile tüm ağ arayüzlerinde 5000 portunda başlatır.

Docker İmajını Oluşturma

Dockerfile‘ı oluşturduktan sonra, bu dosyayı kullanarak bir Docker imajı oluşturabiliriz. flask-docker-app dizininde olduğunuzdan emin olun.

docker build -t flask-app-image .

• docker build: Bir Docker imajı oluşturmak için komut.
• -t flask-app-image: Oluşturulan imaja flask-app-image adını ve latest etiketini verir (varsayılan).
• .: Dockerfile’ın mevcut dizinde olduğunu belirtir.

Bu işlem biraz zaman alabilir, çünkü Python temel imajını indirip bağımlılıkları kuracaktır.

Docker Konteynerini Çalıştırma

İmaj başarıyla oluşturulduktan sonra, bu imajdan bir Docker konteyneri başlatabiliriz:

docker run -d -p 5000:5000 --name my-flask-app flask-app-image

• docker run: Bir Docker konteyneri başlatmak için komut.
• -d: Konteyneri “detached” modda, yani arka planda çalıştırır.
• -p 5000:5000: Host makinesinin 5000 portunu konteynerin 5000 portuna eşler. Böylece host makinesinden localhost:5000 adresine eriştiğimizde konteynerdeki Flask uygulamasına ulaşırız.
• --name my-flask-app: Konteynere my-flask-app adını verir. Bu, konteyneri daha kolay yönetmenizi sağlar.
• flask-app-image: Çalıştırılacak imajın adı.

Uygulamayı Test Etme

Konteynerin çalıştığından emin olmak için:

docker ps

Çalışan konteynerler listesinde my-flask-app konteynerini görmelisiniz.
Ardından, web tarayıcınızda veya curl ile http://localhost:5000 adresine giderek Flask uygulamanızın çalıştığını doğrulayabilirsiniz:

curl http://localhost:5000

Çıktı olarak “Merhaba, Docker ve Flask ile Dünya!” mesajını almalısınız.

Konteynerin loglarını görmek için:

docker logs my-flask-app

Konteyneri durdurmak ve kaldırmak için:

docker stop my-flask-app
docker rm my-flask-app

Docker Compose ile Orchestrasyon

Uygulamamız şu anda tek bir konteynerden oluşuyor. Ancak, gerçek dünya uygulamaları genellikle bir veritabanı, bir ön uç sunucusu (Nginx gibi) veya başka servisler gibi birden fazla konteyner gerektirir. Docker Compose, bu tür çok konteynerli uygulamaları tanımlamak ve yönetmek için idealdir.

Neden Docker Compose?

• Kolay Yapılandırma: Tüm servislerinizi tek bir YAML dosyasında tanımlarsınız.
• Basit Yönetim: Tek bir komutla tüm servisleri başlatabilir, durdurabilir veya yeniden oluşturabilirsiniz.
• Servis Keşfi: Compose, servisler arasında otomatik ağ oluşturma ve isim çözümlemesi sağlar.
• Geliştirme Ortamı: Geliştirme sırasında hızlı iterasyonlar için idealdir (örneğin, kod değişikliklerinde otomatik yeniden yükleme).

docker-compose.yml Dosyası Oluşturma

flask-docker-app dizininin kökünde docker-compose.yml adında bir dosya oluşturun ve içine aşağıdaki içeriği ekleyin:

# docker-compose.yml
version: '3.8' # Docker Compose dosya formatının sürümü

services:
  web: # Flask uygulamamız için servis tanımı
    build: . # Mevcut dizindeki Dockerfile'ı kullanarak imajı oluştur
    ports:
      - "5000:5000" # Host makinesinin 5000 portunu konteynerin 5000 portuna eşle
    volumes:
      - ./app:/app # Yerel 'app' dizinini konteynerdeki '/app' dizinine bağla
    # Bu, geliştirme sırasında kod değişikliklerinin konteynere anında yansımasını sağlar.
    # Üretimde bu volume bağlama yerine, imajın içine kopyalamak tercih edilir.
    environment:
      FLASK_ENV: development # Flask ortam değişkenini ayarlayın (isteğe bağlı)
    restart: always # Konteynerin her zaman yeniden başlatılmasını sağlar (hata durumunda veya host yeniden başlatıldığında)

Bu docker-compose.yml dosyası şunları yapar:

• version: '3.8': Docker Compose dosya formatının sürümünü belirtir.
• services: Uygulamamızdaki tüm servisleri tanımladığımız bölümdür.
• web: Flask uygulamamız için bir servis tanımlar.
• build: .: web servisi için imajın mevcut dizindeki Dockerfile kullanılarak oluşturulacağını belirtir.
• ports: - "5000:5000": Host makinesinin 5000 portunu web konteynerinin 5000 portuna eşler.
• volumes: - ./app:/app: Yerel app dizinini web konteynerindeki /app dizinine bağlar. Bu, geliştirme sırasında kodda yaptığınız değişikliklerin konteyner içinde otomatik olarak güncellenmesini sağlar (hot-reloading). Üretim ortamında genellikle bu tür bir volume kullanmak yerine, tüm kodun imajın içine kopyalandığından emin olmak istenir.
• environment: FLASK_ENV: development: Konteyner içinde bir ortam değişkeni ayarlar.
• restart: always: Konteynerin bir hata durumunda veya host makinesi yeniden başlatıldığında otomatik olarak yeniden başlamasını sağlar.

Docker Compose ile Uygulamayı Çalıştırma

docker-compose.yml dosyasını oluşturduktan sonra, uygulamayı tek bir komutla başlatabiliriz:

docker-compose up --build -d

• docker-compose up: docker-compose.yml dosyasında tanımlanan servisleri başlatır.
• --build: Servisler için imajları yeniden oluşturur (eğer build anahtarı kullanılıyorsa). Bu, Dockerfile‘da veya uygulama kodunda yaptığınız değişikliklerin imaja dahil edilmesini sağlar.
• -d: Servisleri detached modda (arka planda) çalıştırır.

Bu komut, web servisi için Docker imajını oluşturacak (veya güncelleyecek) ve ardından konteyneri başlatacaktır.

Uygulamayı Test Etme

Yine http://localhost:5000 adresine giderek veya curl kullanarak uygulamanın çalıştığını doğrulayabilirsiniz:

curl http://localhost:5000

Çıktı olarak “Merhaba, Docker ve Flask ile Dünya!” mesajını almalısınız.

Çalışan servisleri görmek için:

docker-compose ps

Servislerin loglarını görmek için:

docker-compose logs web

Uygulamayı durdurmak ve konteynerleri kaldırmak için:

docker-compose down

Bu komut, docker-compose.yml dosyasında tanımlanan tüm servisleri durdurur ve ilgili konteynerleri, ağları ve volume’leri (tanımlanmışsa) kaldırır.

Dağıtımda Dikkat Edilmesi Gerekenler

Uygulamamızı Docker ile başarıyla çalıştırdık, ancak üretim ortamında dağıtım yaparken göz önünde bulundurmanız gereken bazı önemli noktalar vardır.

1. Gunicorn/uWSGI Kullanımı

Geliştirme sunucuları (örneğin flask run) üretim ortamı için tasarlanmamıştır. Üretimde Gunicorn veya uWSGI gibi bir WSGI sunucusu kullanmalısınız. Bizim Dockerfile ve docker-compose.yml dosyalarımızda zaten Gunicorn kullanıyoruz, bu iyi bir başlangıçtır.

2. Ortam Değişkenleri

Veritabanı bağlantı bilgileri, API anahtarları gibi hassas bilgileri doğrudan kodunuzda veya Dockerfile içinde tutmaktan kaçının. Bunun yerine, ortam değişkenlerini kullanın. Docker Compose’da environment anahtarını veya Docker’da docker run -e KEY=VALUE seçeneğini kullanabilirsiniz.

3. Nginx ile Ters Proxy

Üretim ortamında, Flask uygulamanızın önüne genellikle Nginx gibi bir ters proxy sunucusu yerleştirilir. Nginx’in faydaları şunlardır:

• Yük Dengeleme: Birden fazla Flask uygulama örneği arasında trafiği dağıtabilir.
• SSL/TLS Sonlandırma: SSL sertifikalarını yönetir ve güvenli HTTPS bağlantıları sağlar.
• Statik Dosya Sunumu: CSS, JavaScript, resimler gibi statik dosyaları doğrudan sunarak Flask uygulamasının yükünü azaltır.
• Hız Limitleme ve Güvenlik: İstemci isteklerini limitleyebilir ve temel güvenlik önlemleri alabilir.

Nginx ile Docker Compose Örneği

docker-compose.yml dosyamızı Nginx’i içerecek şekilde güncelleyelim:

# docker-compose.yml (Nginx ile)
version: '3.8'

services:
  web:
    build: .
    # Nginx ile doğrudan dışarıya açmayız, Nginx üzerinden erişilir
    # ports:
    #   - "5000:5000"
    volumes:
      - ./app:/app
    environment:
      FLASK_ENV: production
    restart: always

  nginx:
    image: nginx:latest # En son Nginx imajını kullan
    ports:
      - "80:80" # Host'un 80 portunu Nginx'in 80 portuna eşle
      # - "443:443" # SSL için 443 portunu da eşleyebilirsiniz
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro # Nginx yapılandırma dosyasını bağla
      # - ./nginx/conf.d:/etc/nginx/conf.d:ro # Ek yapılandırmalar için
    depends_on:
      - web # Nginx'in web servisinden sonra başlamasını sağlar
    restart: always

Şimdi nginx dizini oluşturup içine nginx.conf dosyasını eklememiz gerekiyor:

mkdir nginx

nginx/nginx.conf dosyası:

# nginx/nginx.conf
worker_processes auto;

events {
    worker_connections 1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;

    sendfile        on;
    keepalive_timeout  65;

    server {
        listen 80;
        server_name localhost; # Alan adınızı buraya yazın

        location / {
            proxy_pass http://web:5000; # 'web' servisine 5000 portundan yönlendir
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
        }

        # Statik dosyalarınız varsa bu bloğu kullanabilirsiniz
        # location /static/ {
        #    alias /app/static/; # Flask uygulamasının static dizinini belirtin
        # }
    }
}

Bu Nginx yapılandırması, gelen tüm HTTP isteklerini web servisine (Docker Compose’daki servis adı) 5000 portundan yönlendirir.

Nginx ile uygulamayı başlatmak için:

docker-compose up --build -d

Şimdi http://localhost adresine giderek uygulamanıza Nginx üzerinden erişebilirsiniz.

4. Veri Kalıcılığı (Data Persistence)

Eğer uygulamanız bir veritabanı kullanıyorsa (PostgreSQL, MySQL vb.), verilerin konteyner silindiğinde kaybolmaması için Docker Volume’ları kullanmanız gerekir.

Örnek olarak, bir PostgreSQL veritabanı ekleyelim:

# docker-compose.yml (PostgreSQL ile)
version: '3.8'

services:
  web:
    build: .
    volumes:
      - ./app:/app
    environment:
      FLASK_ENV: production
      DATABASE_URL: postgresql://user:password@db:5432/mydatabase # Veritabanı bağlantı URL'si
    restart: always
    depends_on:
      - db # web servisi db servisinden sonra başlasın

  db:
    image: postgres:13 # PostgreSQL imajı
    environment:
      POSTGRES_DB: mydatabase
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - db_data:/var/lib/postgresql/data # Veritabanı verilerini kalıcı hale getirmek için volume
    restart: always

  nginx:
    image: nginx:latest
    ports:
      - "80:80"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - web
    restart: always

volumes:
  db_data: # db_data adında bir volume tanımla

Bu yapılandırmada, db_data adında bir volume oluşturulur ve PostgreSQL konteynerinin /var/lib/postgresql/data dizinine bağlanır. Bu sayede konteyner silinse bile veritabanı verileri kalıcı olarak saklanır.

5. Güvenlik

• Minimum İzinler: Dockerfile’da root olmayan bir kullanıcı oluşturun ve uygulamayı bu kullanıcıyla çalıştırın (USER komutu).
• Gereksiz Portları Açmayın: Sadece uygulamanızın ihtiyaç duyduğu portları açın.
• İmajları Güncel Tutun: Temel imajlarınızı ve bağımlılıklarınızı düzenli olarak güncelleyin.
• Hassas Verileri Gizleyin: Ortam değişkenleri veya Docker Secrets/Vault gibi araçları kullanarak hassas verileri yönetin.

6. CI/CD Entegrasyonu

Üretim ortamında, uygulamalarınızı otomatik olarak derlemek, test etmek ve dağıtmak için GitLab CI/CD, GitHub Actions veya Jenkins gibi sürekli entegrasyon/sürekli dağıtım (CI/CD) araçlarını kullanmanız önerilir. Bu, dağıtım süreçlerini hızlandırır ve insan hatasını azaltır.

Sonuç

Bu rehberde, bir Flask uygulamasını Docker kullanarak Ubuntu 20.04 üzerinde nasıl oluşturacağımızı ve dağıtacağımızı ayrıntılı olarak inceledik. İlk olarak, sistemimize Docker ve Docker Compose’u kurduk. Ardından, basit bir Flask uygulaması oluşturup bunu bir Dockerfile ile konteynerize ettik. Son olarak, docker-compose.yml kullanarak çok konteynerli bir uygulama yapısı kurmayı ve Nginx ile ters proxy gibi üretim ortamı dağıtımında dikkat edilmesi gereken önemli noktaları ele aldık.

Flask ve Docker’ın birleşimi, geliştiricilere hızlı, tutarlı ve ölçeklenebilir uygulamalar oluşturma ve dağıtma gücü verir. Konteynerizasyon, “benim makinemde çalışıyordu” sorununu ortadan kaldırır ve geliştirme ile üretim ortamları arasında tutarlılık sağlar. Docker Compose ise, karmaşık çok servisli uygulamaların yönetimini basitleştirir.

Bu rehber, Flask uygulamanızı Docker ile başarılı bir şekilde dağıtmanız için sağlam bir temel sağlamıştır. Daha karmaşık senaryolar için Docker Swarm veya Kubernetes gibi konteyner orkestrasyon araçlarını, bulut platformlarını (AWS ECS, Google Cloud Run, Azure Container Instances) ve gelişmiş izleme/günlükleme çözümlerini araştırmayı düşünebilirsiniz. Unutmayın, modern uygulama geliştirme ve dağıtım süreçlerinde öğrenme ve adapte olma süreklidir. Bu bilgilerle, kendi Dockerize edilmiş Flask uygulamalarınızı güvenle oluşturmaya ve dağıtmaya hazırsınız!