Python: Tworzenie REST API

Jak stworzyć REST API za pomocą Flask

👋 Witamy w dokumentacji Stackhero!

Stackhero oferuje gotowe do użycia rozwiązanie Python cloud, które zapewnia wiele korzyści, w tym:

  • Wdrażaj swoją aplikację w kilka sekund za pomocą prostego git push.
  • Używaj własnej nazwy domeny i korzystaj z automatycznej konfiguracji certyfikatów HTTPS dla zwiększonego bezpieczeństwa.
  • Ciesz się spokojem dzięki automatycznym kopiom zapasowym, aktualizacjom jednym kliknięciem oraz prostemu, przejrzystemu i przewidywalnemu cennikowi.
  • Uzyskaj optymalną wydajność i solidne zabezpieczenia dzięki prywatnej i dedykowanej VM.

Oszczędzaj czas i upraszczaj sobie życie: wypróbowanie rozwiązania Python cloud hosting Stackhero zajmuje tylko 5 minut!

Ta dokumentacja to przyjazny dla początkujących przewodnik po tworzeniu REST API w Pythonie.

W tym przykładzie używamy Flask, lekkiego i łatwego w użyciu mikro-frameworka, który umożliwia szybkie tworzenie aplikacji webowych.

Wymagania wstępne

Przed rozpoczęciem upewnij się, że Twój komputer jest wyposażony w następujące narzędzia:

  1. Python
  2. pip
  3. git
  4. asdf

Jeśli Twoje środowisko deweloperskie nie jest jeszcze skonfigurowane, zapoznaj się z przewodnikiem Development platform dla szczegółowych instrukcji. Alternatywnie, możesz użyć platformy online Code-Hero. Code-Hero zapewnia IDE i terminal online, z wszystkimi niezbędnymi narzędziami zainstalowanymi, dzięki czemu możesz zacząć kodować natychmiast bez instalacji.

Python REST API uruchomione w Code-Hero, dostępne bezpośrednio z przeglądarkiPython REST API uruchomione w Code-Hero, dostępne bezpośrednio z przeglądarki

Tworzenie nowego projektu

Pierwszym krokiem jest utworzenie nowego katalogu projektu. Dla tego przewodnika nazwiemy go myRestApi:

mkdir myRestApi
cd myRestApi

Następnie ustaw wersję Pythona na najnowszą dostępną za pomocą asdf i zainicjuj repozytorium Git:

asdf install python latest \
  && asdf local python latest

echo "__pycache__/" >> .gitignore

git init
git add -A .
git commit -m "First commit"

Instalowanie zależności Flask

W tym przykładzie potrzebujemy tylko jednej zależności: Flask.

Flask to lekki framework webowy, który umożliwia szybki rozwój aplikacji webowych. Jest zaprojektowany tak, aby był prosty i łatwy w użyciu, pozwalając deweloperom szybko tworzyć i wdrażać usługi webowe. Wbudowane wsparcie dla routingu, szablonów i obsługi żądań HTTP sprawia, że Flask jest doskonałym wyborem do tworzenia REST API.

Zainstaluj Flask (i python-dotenv) za pomocą pip:

pip install Flask python-dotenv

Instalujemy tutaj moduły Flask i python-dotenv. Wkrótce zobaczysz, dlaczego używamy python-dotenv (spoiler: chodzi o zarządzanie zmiennymi środowiskowymi).

Po instalacji zamroź wersje pakietów do pliku requirements.txt:

pip freeze > requirements.txt

Zamrożenie zależności zapewnia, że Twój serwer produkcyjny lub współpracownicy używają tych samych wersji co Ty. Kilka sekund pracy może zapobiec wielu przyszłym problemom.

Implementacja REST API za pomocą Flask

Przejdźmy teraz do kodu!

Utwórz plik o nazwie app.py i wstaw następujący kod:

import os
from dotenv import load_dotenv
from flask import Flask, jsonify, request

# Załaduj zmienne środowiskowe z pliku .env, gdy nie jesteśmy w produkcji
if os.environ.get('ENV') != 'production':
    load_dotenv()

# Utwórz aplikację Flask
app = Flask(__name__)

# Przykładowy zestaw danych
tasks = [
    {
        'id': 1,
        'title': 'Kup zakupy',
        'description': 'Mleko, Ser, Pizza, Owoce',
        'done': False
    },
    {
        'id': 2,
        'title': 'Naucz się Pythona',
        'description': 'Naucz się podstaw programowania w Pythonie',
        'done': False
    }
]

# Trasa '/api/tasks' (GET) do listowania wszystkich zadań
@app.route('/api/tasks', methods=['GET'])
def get_tasks():
    return jsonify({'tasks': tasks})

# Trasa '/api/tasks/<task_id>' (GET) do pobierania konkretnego zadania po jego ID
@app.route('/api/tasks/<int:task_id>', methods=['GET'])
def get_task(task_id):
    task = [task for task in tasks if task['id'] == task_id]
    if len(task) == 0:
        return jsonify({'error': 'Zadanie nie znalezione'}), 404
    return jsonify({'task': task[0]})

# Trasa '/api/tasks' (POST) do tworzenia nowego zadania
@app.route('/api/tasks', methods=['POST'])
def create_task():
    if not request.json or 'title' not in request.json:
        return jsonify({'error': 'Tytuł jest wymagany'}), 400
    task = {
        'id': tasks[-1]['id'] + 1,
        'title': request.json['title'],
        'description': request.json.get('description', ""),
        'done': False
    }
    tasks.append(task)
    return jsonify({'task': task}), 201

# Uruchom serwer API
if __name__ == '__main__':
    if os.environ.get('ENV') == 'production':
        app.run()
    else:
        app.run(host='0.0.0.0', port=8080, debug=True)

Aby uruchomić serwer, wykonaj:

python app.py

Z opcją host='0.0.0.0' możesz również uzyskać dostęp do swojego API za pomocą przeglądarki, korzystając z Code-Hero. Wystarczy przejść do http://<XXXXXX>.stackhero-network.com:8080/api/tasks, zastępując <XXXXXX> swoją domeną Code-Hero.

Testowanie REST API

Gdy serwer działa, możesz z nim interakcjonować za pomocą cURL. Oto kilka przykładów:

  • Pobierz wszystkie zadania:

    curl -s http://localhost:8080/api/tasks
{
  "tasks": [
    {
      "description": "Mleko, Ser, Pizza, Owoce",
      "done": false,
      "id": 1,
      "title": "Kup zakupy"
    },
    {
      "description": "Naucz się podstaw programowania w Pythonie",
      "done": false,
      "id": 2,
      "title": "Naucz się Pythona"
    }
  ]
}

  • Pobierz zadanie z ID 2:

    curl -s http://localhost:8080/api/tasks/2
{
  "task": {
    "description": "Naucz się podstaw programowania w Pythonie",
    "done": false,
    "id": 2,
    "title": "Naucz się Pythona"
  }
}

  • Utwórz nowe zadanie:

    curl -s -X POST -H "Content-Type: application/json" \
-d '{"title": "Nowe zadanie", "description": "Utworzone za pomocą cURL"}' \
http://localhost:8080/api/tasks
{
  "task": {
    "description": "Utworzone za pomocą cURL",
    "done": false,
    "id": 3,
    "title": "Nowe zadanie"
  }
}

Wskazówka: Przekieruj wynik do jq, aby upiększyć JSON. Na przykład, curl -s http://localhost:8080/api/tasks/2 | jq daje bardziej czytelny wynik.

Przykład REST API w Pythonie używającego Flask, uruchomionego w Stackhero Code-Hero, z serwerem (1) i klientem używającym cURL (2)Przykład REST API w Pythonie używającego Flask, uruchomionego w Stackhero Code-Hero, z serwerem (1) i klientem używającym cURL (2)

Zarządzanie zmiennymi środowiskowymi

Zmienne środowiskowe są kluczowe dla ochrony wrażliwych informacji, takich jak dane logowania do bazy danych czy klucze API. Istnieją dwa główne korzyści z używania zmiennych środowiskowych:

  1. Twoje sekrety nie są przechowywane w repozytorium Git, co zapewnia, że osoby nieupoważnione nie mogą uzyskać dostępu do Twoich danych nawet jeśli uzyskają dostęp do Twojego kodu źródłowego.
  2. Możesz używać różnych danych logowania dla różnych środowisk (na przykład produkcja kontra rozwój).

Aby zarządzać zmiennymi środowiskowymi, używamy modułu python-dotenv. Najpierw zainstaluj go, jeśli jeszcze tego nie zrobiłeś:

pip install python-dotenv
pip freeze > requirements.txt

Następnie utwórz plik .env w katalogu głównym projektu i dodaj swoje zmienne środowiskowe dla środowiska deweloperskiego. Na przykład:

ENV="development"
DATABASE_PASSWORD="secretPassword"
THIRD_API_PRIVATE_KEY="secretKey"

Na koniec dodaj plik .env do .gitignore, aby zachować bezpieczeństwo:

echo ".env" >> .gitignore

Aby uzyskać dostęp do tych zmiennych środowiskowych w Pythonie, po prostu użyj os.environ.get():

import os

print(os.environ.get('ENV'))

Plik .env jest używany tylko dla środowiska deweloperskiego. Dla stagingu lub produkcji ustaw zmienne środowiskowe na pulpicie Stackhero w konfiguracji usługi Python.

Przygotowanie Pythona i Flask do wdrożenia produkcyjnego

Chociaż ten przewodnik używa wbudowanego serwera deweloperskiego Flask, dla produkcji konieczne jest użycie serwera WSGI gotowego do produkcji, takiego jak Gunicorn. Wykonaj te kroki:

  1. Zainstaluj Gunicorn:

    pip install gunicorn
pip freeze > requirements.txt

  2. Uruchom swoją aplikację za pomocą Gunicorn z argumentem app:app (gdzie pierwszy app to nazwa pliku, a drugi app to instancja Flask):

    ENV=production gunicorn app:app \
  --error-logfile - \
  -b 0.0.0.0:8080

  3. Utwórz Makefile, aby uprościć przełączanie między trybami deweloperskim i produkcyjnym:

    .DEFAULT_GOAL := dev

# Domyślnie Stackhero dla Pythona wykonuje regułę "run". Zastępujemy ją, aby wykonać regułę 'prod'.
run: prod

prod:
 	ENV=production gunicorn app:app \
 	  --error-logfile - \
 	  -b 0.0.0.0:8080

dev:
 	python app.py

Możesz uruchomić swój serwer w trybie deweloperskim używając make dev (lub po prostu make), a w trybie produkcyjnym używając make prod.

Wdrażanie kodu Python do produkcji

Najprostszym sposobem na wdrożenie projektu Python jest użycie usługi hostingu w chmurze Python od Stackhero. Kluczowe funkcje obejmują:

  • Wdrożenie za pomocą prostego git push
  • Dostosowywalna domena z automatycznym zarządzaniem certyfikatami TLS (HTTPS)
  • Działa na prywatnej i dedykowanej maszynie wirtualnej dla maksymalnego bezpieczeństwa
  • Obsługuje HTTP/2, TLS 1.3 (HTTPS), WebSockets, kompresję GZIP & Brotli, ETag oraz dostęp do portów TCP/UDP

Konfiguracja usługi "Stackhero for Python"

Aby wdrożyć swój kod na Stackhero, wykonaj te kroki:

  1. Pobierz swój klucz publiczny używając:

    cat ~/.ssh/id_*.pub

  2. W panelu Stackhero przejdź do swojej usługi "Stackhero for Python" i kliknij przycisk "Configure".

  3. Skopiuj klucz publiczny z pierwszego kroku i wklej go w polu "SSH public keys" lub "Key".

  4. Zatwierdź konfigurację, klikając przycisk "Validate" na dole strony.

Konfiguracja klucza publicznego "Stackhero for Python"Konfiguracja klucza publicznego "Stackhero for Python"

Nie masz kluczy SSH? Utwórz je, uruchamiając:

ssh-keygen -t ed25519

Na koniec skonfiguruj swoje repozytorium do wdrożenia na Stackhero. W folderze projektu dodaj zdalne repozytorium Git używając polecenia podanego w Twojej usłudze Stackhero (zastąp <XXXXXX> domeną swojej usługi):

git remote add stackhero ssh://stackhero@<XXXXXX>.stackhero-network.com:222/project.git

Polecenie Git remotePolecenie Git remote

Wdrażanie do produkcji

Gdy wszystko jest skonfigurowane, wdroż swój kod do produkcji za pomocą jednego polecenia:

git push stackhero main

Upewnij się, że dodasz i zatwierdzisz swoje zmiany przed wypchnięciem kodu do produkcji. W Stackhero Code-Hero, możesz szybko zatwierdzić zmiany, używając Command Palette (naciśnij Ctrl+Shift+P na Windows/Linux lub Cmd+Shift+P na macOS i wpisz Git: Commit).

Po wdrożeniu odwiedź swój URL API pod adresem https://<XXXXXX>.stackhero-network.com/api/tasks (zastąp <XXXXXX> domeną swojej usługi), aby zobaczyć swoje API Flask w akcji.

Podsumowanie

Postępując zgodnie z tym przewodnikiem, teraz rozumiesz, jak stworzyć REST API za pomocą Flask. Z tą wiedzą możesz pewnie rozwijać i rozszerzać swoje aplikacje RESTful, integrując je z różnymi usługami front-end i back-end.

Other articles for Python