Python, Flask, MongoDB, Docker ile RestAPI Geliştirme¶

Bu eğitim serisinde python, flask, mongodb ve docker ile bir rest api geliştireceğiz.

Part 1¶

Kurulum ve Proje Yapısı¶

Uygulamayı çalıştırma ve ilk view fonksiyonu ve endpoint(uç noktayı) ekleme Requirements(Gereksinimler)

python3.11
Docker version 20.10.21
Flask==2.2.2
flask-mongoengine==1.0.0
flask-marshmallow==0.14.0
apifairy==1.3.0

Flask_MongoDB_Docker adında bir proje klasörü oluşturalım.

Yeni bir python projesine başlarken sanal bir ortam oluşturmak iyi bir pratiktir.

Proje klasörüne aşağıdaki komutu yazarak sanal ortamı oluşturalım.

$cd Flask_MongoDB_Docker/
# Sanal ortamımı env311 olarak adlandırdım
$ python3.11 -m venv env311
# Sanal ortamı etkinleştirin (macos/linux kullanıcıları)
$ source env311/bin/activate
# Windows kullanıcısıysanız bu şekilde etkinleştirebilirsiniz.
# $ env311\Scripts\activate

- Flask, Flask-MongoEngine ve diğer bağımlılıkları kurun

$ pip install flask
$ pip install flask-mongoengine
$ pip install python-dotenv
$ pip install flask-marshmallow
$ pip install apifairy

- Proje Dosyaları ve Klasör Yapısı

$ tree -I env311 Flask_MongoDB_Docker 

Flask_MongoDB_Docker
├── Dockerfile
├── README.md
├── api
│   ├── __init__.py
│   ├── app.py
│   ├── models.py
│   ├── schemas.py
│   └── views.py
├── config.py
├── docker-compose.yml
├── main.py
└── requirements.txt

1 directory, 11 files

- config.py üzerinde kodlamaya başlayalım

# config.py
import os
from dotenv import load_dotenv

load_dotenv()

BASE_DIR = os.path.abspath(os.path.dirname(__file__))

class Config:
    # security options
    SECRET_KEY = os.environ.get('SECRET_KEY', 'top-secret!')

    # mongo db options eklenecek

- Config sınıfını tanımladıktan sonra api/app.py üzerinde app instance oluşturmak için bir fonksiyon ekleyeceğiz.

# api/app.py
from flask import Flask

# internals
from config import Config

def create_app(config_class=Config):
    app = Flask(__name__)
    app.config.from_object(config_class)

    return app

- create_app fonksiyonunu çağırabilmek için api/init.py içine aktaralım(import)

# api/__init__.py
from api.app import create_app

- Son olarak main.py üzerinde create_app fonksiyonunu kullanarak bir app oluşturacağız.

# main.py
from api import create_app

app = create_app()

- Projeyi çalıştırmak için proje klasörü içinde .env dosyası oluşturun. FLASK_APP değişkenini aşağıdaki gibi tanımlayın ve ayrıca debugger(hata ayıklayıcıyı) etkinleştirmek için FLASK_DEBUG değişkenini tanımlayın.

# Flask_MongoDB_Docker/.env
FLASK_APP=main.py
FLASK_DEBUG=1

- Artık projemizi terminalde çalıştırabiliriz.

# Flask_MongoDB_Docker/
$ flask run

- Aşağıdaki gibi bir çıktı göreceksiniz

# output of "flask run" command

 * Serving Flask app 'main.py'
 * Debug mode: on
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on http://127.0.0.1:5000
Press CTRL+C to quit
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 854-344-911

- http://127.0.0.1:5000 adresine GET isteği yaparsanız HTTP 404 Hatası alırsınız. Çünkü herhangi bir endpoint (uç nokta, kaynak, yol) oluşturmadık.

<!doctype html>
<html lang=en>
  <title>404 Not Found</title>
  <h1>Not Found</h1>
  <p>The requested URL was not found on the server. If you entered the URL
    manually please check your spelling and try again.</p>

- api/views.py üzerine ilk endpoint ve view fonksiyonunu yazalım

# api/views.py
from flask import Blueprint

books_bp = Blueprint("books", __name__)


@books_bp.route("/books/", methods=["GET"])
def books():
    book_list = [
        {"id":1, "name":"Python Flask & MongoDB", "author":"Adnan Kaya", "published_year": 2023},
        {"id":2, "name":"Python for Absolute Beginners", "author":"Adnan Kaya", "published_year": 2025},
        {"id":3, "name":"Learn Django by Developing Projects", "author":"Adnan Kaya", "published_year": 2024},
    ]

    return book_list

- İlk önce Blueprint'i import ediyoruz - Ve parametre olarak "books" ve name vererek bir Blueprint nesnesi oluşturun. - Bu nesne books_bp değişkenine atandı. - Endpointleri tanımlarken books_bp nesnesini kullanacağız. - Yalnızca "/books/" uç noktasında GET isteğine izin veriyoruz - books adında bir fonksiyon oluşturuyoruz ve bu 3 adet dict nesnesi içeren bir liste yani book_list döndürüyor. - Ve şimdi create_app fonksiyonunda (api/app.py'de) books blueprint instance(örneği) tanımlayın.

# api/app.py
from flask import Flask

# internals
from config import Config

def create_app(config_class=Config):
    app = Flask(__name__)
    app.config.from_object(config_class)

    # blueprints
    API_URL_PREFIX = "/api/v1"
    from api.views import books_bp

    app.register_blueprint(books_bp, url_prefix=API_URL_PREFIX)

    return app

- http://localhost:5000/api/v1/books/ için bir GET isteği yaparsanız, aşağıdaki yanıtı alırsınız

[
  {
    "author": "Adnan Kaya",
    "id": 1,
    "name": "Python Flask & MongoDB",
    "published_year": 2023
  },
  {
    "author": "Adnan Kaya",
    "id": 2,
    "name": "Python for Absolute Beginners",
    "published_year": 2025
  },
  {
    "author": "Adnan Kaya",
    "id": 3,
    "name": "Learn Django by Developing Projects",
    "published_year": 2024
  }
]

Part 2¶

Mongoengine'i uygulamadan önce, mongodb'yi bir docker container(konteyner) olarak çalıştıralım. Terminalde aşağıdaki gibi çalıştırabilirsiniz.

docker run --name mongodb -d -p 27017:27017 -e  MONGO_INITDB_ROOT_USERNAME=developer -e MONGO_INITDB_ROOT_PASSWORD=developer mongo

- Bu komut, aşağıdaki gibi bir container id yazdırır:

ec1fc7b8439dfeb57cf06f93a0271935123cd1d1467be9e02bc4ece5b9046e77

Docker konteyneri kontrol edelim ve mongo kabuğunu/shell (mongosh) açalım:

$ docker ps -a
# output
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                      NAMES
ec1fc7b8439d   mongo     "docker-entrypoint.s…"   3 minutes ago   Up 3 minutes   0.0.0.0:27017->27017/tcp   mongodb

Mongo shell

$ docker exec -it mongodb mongosh -u developer -p developer

# eğer başarılı ise aşağıdaki gibi görmelisiniz
test>
# databaseleri görmek için `show dbs` komutunu yazabilirsiniz.
test> show dbs
admin   100.00 KiB
config   60.00 KiB
local    72.00 KiB

Şimdi config.py üzerinde flask uygulaması için mongodb konfigürasyonları ekleyelim

# config.py
import os
from dotenv import load_dotenv

# .env yi yükler
load_dotenv()

BASE_DIR = os.path.abspath(os.path.dirname(__file__))

class Config:
    # security options
    SECRET_KEY = os.environ.get('SECRET_KEY', 'top-secret!')

    # mongo db options
    MONGODB_SETTINGS = [
        {
            "db": os.environ.get("MONGODB_DBNAME","mydb"),
            "host": os.environ.get("MONGODB_HOST","localhost"),
            "port": int(os.environ.get("MONGODB_PORT")) or 27017,
            "alias": "default",
            "username": os.environ.get("MONGODB_USERNAME","developer"),
            "password": os.environ.get("MONGODB_PASSWORD","developer")
        }
    ]

Ayrıca bu ortam değişkenlerini(environment variables) .env dosyasına ekleyebiliriz.

FLASK_APP=main.py
FLASK_DEBUG=1
MONGODB_DBNAME=mydb
MONGODB_HOST=localhost
MONGODB_PORT=27017
MONGODB_USERNAME=developer
MONGODB_PASSWORD=developer

Şimdi api/app.py'de MongoEngine örneği oluşturuluyor(instantiating)

# api/app.py
from flask import Flask
from flask_mongoengine import MongoEngine # yeni

# internals
from config import Config

db = MongoEngine() # yeni

def create_app(config_class=Config):
    app = Flask(__name__)
    app.config.from_object(config_class)

    # database mongodb
    db.init_app(app) # yeni

    # blueprints
    API_URL_PREFIX = "/api/v1"
    from api.views import books_bp

    app.register_blueprint(books_bp, url_prefix=API_URL_PREFIX)

    return app

api/init.py içine db'yi de import etmeliyiz.

# api/__init__.py
from api.app import create_app, db

Şimdi modellerimizi oluşturma zamanı. models.py'yi açın

# internals
from api import db

class Book(db.Document):
    name = db.StringField(max_length=64)
    author = db.StringField(max_length=32)
    published_year = db.IntField(min=610)

    def __str__(self) -> str:
        return self.name

Modelimizi oluşturduktan sonra flask shell üzerinde oynayalım, terminali açabilirsiniz

$ flask shell
# Python 3.11.0 (v3.11.0:deaf509e8f, Oct 24 2022, 14:43:23) [Clang 13.0.0 (clang-1300.0.29.30)] on darwin
# App: api.app
# Instance: /<my-path>/Flask_MongoDB_Docker/instance
>>> from api.models import *
>>> book = Book(name="Python Flask", author="Adnan Kaya", published_year=2023)
>>> book.save()
<Book: Python Flask>

İşte bu! Veritabanında ilk kaydımızı oluşturduk. Mongo kabuğunda/shell kontrol edelim

test> show dbs
admin   100.00 KiB
config   92.00 KiB
local    72.00 KiB
mydb      8.00 KiB # our database is created

# Bizim veritabanı mydb olduğu icin onu seciyoruz
test> use mydb
switched to db mydb

# show collections(tablolari goster)
mydb> show collections
book

# book kayitlarini getir
mydb> db.book.find()
[
  {
    _id: ObjectId("638fb5df4653579e2ea4367c"),
    name: 'Python Flask',
    author: 'Adnan Kaya',
    published_year: 2023
  }
]

2 kayıt daha ekledik. Şimdi api'miz aracılığıyla veritabanından veri almak için api/views.py dosyasını düzenleyelim.

# api/views.py
from flask import Blueprint
# internals
from .models import Book

books_bp = Blueprint("books", __name__)


@books_bp.route("/books/", methods=["GET"])
def books():
    book_list = Book.objects.all()

    return book_list

Şimdi http://localhost:5000/api/v1/books/ adresine bir GET isteği yapın. Yanıt durumu 200, ancak herhangi bir yanıt verimiz yok ve ayrıca terminalde hatamız var:

127.0.0.1 - - [07/Dec/2022 00:53:38] "GET /api/v1/books/ HTTP/1.1" 200 -
Error on request:
Traceback (most recent call last):
  File "/<mypath>/Flask_MongoDB_Docker/env311/lib/python3.11/site-packages/werkzeug/serving.py", line 335, in run_wsgi
    execute(self.server.app)
  File "/<mypath>/Flask_MongoDB_Docker/env311/lib/python3.11/site-packages/werkzeug/serving.py", line 325, in execute
    write(data)
  File "/<mypath>/Flask_MongoDB_Docker/env311/lib/python3.11/site-packages/werkzeug/serving.py", line 293, in write
    assert isinstance(data, bytes), "applications must write bytes"
AssertionError: applications must write bytes

Hata mesajı özeti

AssertionError: applications must write bytes

Yani dönülecek veri byte türünde olmalıdır. views.py'deki book_list türü şu şekildedir:
```
<class 'flask_mongoengine.BaseQuerySet'>
```
book_list ise BaseQuerySet türündedir.

Bu sorunun üstesinden gelmek için flask.jsonify() kullanmalıyız. api/views.py dosyasını açın ve jsonify'ı içe aktarın ve jsonify'a ileterek book_list'i döndürün

from flask import Blueprint, jsonify # yeni
# internals
from .models import Book

books_bp = Blueprint("books", __name__)


@books_bp.route("/books/", methods=["GET"])
def books():
    book_list = Book.objects.all()

    return jsonify(book_list) # yeni

Şimdi http://localhost:5000/api/v1/books/ adresine bir GET isteği yapın ve aşağıdaki sonucu alacaksınız.

[
  {
    "_id": {
      "$oid": "638fb5df4653579e2ea4367c"
    },
    "author": "Adnan Kaya",
    "name": "Python Flask",
    "published_year": 2023
  },
  {
    "_id": {
      "$oid": "638fb80a4653579e2ea4367d"
    },
    "author": "Adnan Kaya",
    "name": "Python Django",
    "published_year": 2025
  },
  {
    "_id": {
      "$oid": "638fb83b4653579e2ea4367e"
    },
    "author": "Adnan Kaya",
    "name": "Python Tkinter",
    "published_year": 2026
  }
]

_id ve $oid (object id) otomatik olarak oluşturulur.

Part 3¶

Projemizi dockerize edip yeni modeller ekleyeceğiz. Başlayalım!

docker-compose.yml dosyamızı yazmaya başlayacağız.

# Flask_MongoDB_Docker/docker-compose.yml

version: '3.7'
services:

  db:
    image: mongo:latest
    container_name: mymongodb
    ports:
      - 27017:27017
    volumes:
      - mongo_data:/data/db

volumes:
  mongo_data:

Yalnızca mongodb'nin en son imajını kullanan ve konteynerin adı mymongodb olan db servisini ekledik (bu container adına dikkat edin çünkü flask(web) servisini eklediğimizde bu container adını flask konteynerinden mongo konteynerine bağlanmak için kullanacağız).

Son olarak volumes mongo_data olarak adlandırdık. Aşağıdaki komutu yazarak mongodb container başlatalım:

# docker-compose.yml dosyasında db servisi bizim mongodb servisimizdir.
$ docker compose up -d --build db

# output
[+] Running 2/2
 ⠿ Network flask_mongodb_docker_default  Created                                                                           0.0s
 ⠿ Container mymongodb                   Started

Konteyner statusunu kontrol edelim

$ docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS            PORTS                      NAMES
dfa10167aa02   mongo:latest   "docker-entrypoint.s…"   2 minutes ago   Up 2 minutes      0.0.0.0:27017->27017/tcp   mymongodb

.env dosyamıza bir göz atalım

FLASK_APP=main.py
FLASK_DEBUG=1
MONGODB_DBNAME=mydb
MONGODB_HOST=localhost
MONGODB_PORT=27017
MONGODB_USERNAME=developer
MONGODB_PASSWORD=developer

Şu anda sadece mongodb olan 1 konteynerimiz var. Terminalimizden flaski çalıştıracağız. Mongodb'ye doğrudan flask'tan bağlandığımız için (herhangi bir konteynerden değil) , MONGODB_HOST'u localhost olarak kullanacağız. Flask'i docker compose ile başlattığımızda MONGODB_HOST değeri mongodb servisinin container adı olacaktır. Flask'i çalıştıralım:
```
$ source env311/bin/activate
(env311)$ flask run
```
http://127.0.0.1:5000/api/v1/books/ adresine bir GET isteği yapın
HTTP Status 200 ile boş liste [ ] yanıtı almalısınız. Ancak part2'de 3 kayıt eklemiştik. Verilerimiz nerede?
Part2'de container verilerini bağlamadık. Bu nedenle önceki konteyner kaldırıldığında 3 adet kayıt da kaybedildi.
docker-compose.yml dosyasında, container kaldırılsa bile verilerimizi kalıcı olarak saklamak için birimimizi/volume belirledik.

Yeniden veri eklemeden şimdi flask'ı dockerize edelim ve mongodb konteynerine bağlanalım. docker-compose-yml dosyasını açın ve servislere web ekleyin.

# Flask_MongoDB_Docker/docker-compose.yml
version: '3.7'
services:
  web:
    container_name: flask_mongodb_docker_tutorial
    build:
      context: .
      dockerfile: ./Dockerfile
    volumes:
      - .:/usr/src/app/
    ports:
      - 5000:5000
    env_file:
      - ./.env
    depends_on:
      - db
    stdin_open: true
    tty: true

  db:
    image: mongo:latest
    container_name: mymongodb
    ports:
      - 27017:27017
    volumes:
      - mongo_data:/data/db

volumes:
  mongo_data:

Şimdi .env dosyasını aşağıdaki gibi düzenleyin

FLASK_APP=main.py
FLASK_DEBUG=1
MONGODB_DBNAME=mydb
# MONGODB_HOST=localhost
# docker compose kullandigimizda MONGODB_HOST=container_name olmali ki
# web ile db servisleri haberlesebilsin
MONGODB_HOST=mymongodb
MONGODB_PORT=27017
MONGODB_USERNAME=developer
MONGODB_PASSWORD=developer

Şimdi Dockerfile dosyamızı düzenleyeceğiz.

# Flask_MongoDB_Docker/Dockerfile

# python3.11 resmi imajı indir
FROM python:3.11.0-slim-buster

# work directory belirle
WORKDIR /usr/src/app

# environment variables / ortam değişkenleri belirle
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# sistem bagimliliklarini kur
RUN apt-get update && apt-get install -y netcat

RUN pip install --upgrade pip
# requirements.txt yi container WORKDIR dizinine kopyala
COPY ./requirements.txt /usr/src/app/requirements.txt
# proje paketlerini kur
RUN pip install -r requirements.txt

# projeyi WORKDIR dizinine kopyala
COPY . /usr/src/app/

# development modda çalıştır
CMD ["python", "-m", "flask", "run", "--host=0.0.0.0", "--port=5000"]

Docker komutları için yorum satırları ekledim. Kolayca anlayabilirsiniz.

Şimdi terminalde çalışan flask uygulamasını durdurun. Ve flask(web) servisi oluşturun.

$ docker compose up -d --build web

# output
[+] Building 2.6s (12/12) FINISHED                                                                                                    
 # ...
 # .....
[+] Running 2/2
 ⠿ Container mymongodb                      Running                                                                              0.0s
 ⠿ Container flask_mongodb_docker_tutorial  Started

Container status kontrol edelim

$ docker ps
CONTAINER ID   IMAGE                      COMMAND                  CREATED          STATUS          PORTS                      NAMES
ccd7f1c0de54   flask_mongodb_docker-web   "python -m flask run…"   4 minutes ago    Up 3 minutes    0.0.0.0:5000->5000/tcp     flask_mongodb_docker_tutorial
dfa10167aa02   mongo:latest               "docker-entrypoint.s…"   37 minutes ago   Up 37 minutes   0.0.0.0:27017->27017/tcp   mymongodb

Artık bir GET isteğini http://127.0.0.1:5000/api/v1/books/ adresine yapabilir ve yanıt olarak boş listeyi ve durumunu 200 olarak alabilirsiniz.

Yeni kayıtlar eklemeden önce, models.py'yi düzenleyelim ve modeller arasında ilişki kurmak için yeni model ekleyelim.

# Flask_MongoDB_Docker/api/models.py
# internals
from api import db


class Author(db.Document):
    firstname = db.StringField(max_length=64)
    lastname = db.StringField(max_length=64)

    def __str__(self):
        return f"{self.firstname} {self.lastname}"


class Book(db.Document):
    name = db.StringField(max_length=64)
    author = db.ReferenceField(document_type=Author)
    published_year = db.IntField(min=610)

    def __str__(self) -> str:
        return self.name

Her kitabın bir yazarı vardır. Basit ilişki (Birden Çoğa / One-To-Many)

Flask kabuğunda author ve book kayıtları oluşturalım. Öncelikle flask konteynerine girmemiz gerekiyor.

$ docker compose exec web sh
# ls
Dockerfile  README.md  __pycache__  api  config.py  docker-compose.yml env311 main.py  requirements.txt
# pwd
/usr/src/app

Şimdi flask shell

# flask shell
Python 3.11.0 (main, Dec  6 2022, 08:43:25) [GCC 8.3.0] on linux
App: api.app
Instance: /usr/src/app/instance
>>>

Kayıtlar ekleyelim

>>> from api.models import Author, Book
>>> a1 = Author.objects.create(firstname="Adnan", lastname="Kaya")
>>> a2 = Author.objects.create(firstname="Recep", lastname="Alkurt")
>>> a1
<Author: Adnan Kaya>
>>> a2
<Author: Recep Alkurt>
>>> b1 = Book.objects.create(author=a1, name="Flask 101", published_year=2023)
>>> b2 = Book.objects.create(author=a2, name="Angular 101", published_year=2023)
>>> b3 = Book.objects.create(author=a1, name="Django 101", published_year=2025)
>>> b4 = Book.objects.create(author=a1, name="Scrapy 101", published_year=2024)
>>> b1
<Book: Flask 101>
>>> b1.author
<Author: Adnan Kaya>
>>> b2
<Book: Angular 101>
>>> b2.author
<Author: Recep Alkurt>

HARİKA! Veritabanına 2 yazar ve 4 kitap ekledik.

views.py dosyasına bir göz atalım (Şimdiye kadar hiçbir şeyi değiştirmedik)

from flask import Blueprint, jsonify
# internals
from .models import Book

books_bp = Blueprint("books", __name__)


@books_bp.route("/books/", methods=["GET"])
def books():
    book_list = Book.objects.all()

    return jsonify(book_list)

http://127.0.0.1:5000/api/v1/books/

Python, Flask, MongoDB, Docker ile RestAPI Geliştirme¶

Part 1¶

Kurulum ve Proje Yapısı¶

Part 2¶

Part 3¶

Part 4¶

Part 5¶

Kodlar için github repo¶