Python: Tworzenie REST API

Przewodnik krok po kroku po budowie REST API z Flask w Pythonie

👋 Witamy w dokumentacji Stackhero!

Stackhero oferuje gotowe do użycia Python cloud, które upraszcza proces wdrażania:

Wdrażaj swoją aplikację na produkcję w kilka sekund za pomocą prostego git push.

Korzystaj z własnej nazwy domeny, z automatyczną konfiguracją certyfikatu HTTPS – bezpieczne połączenia są obsługiwane za Ciebie.

Polegaj na automatycznych backupach, aktualizacjach jednym kliknięciem oraz przewidywalnych kosztach, dzięki czemu możesz skupić się na kodzie, a nie na zarządzaniu infrastrukturą.

Korzystaj z wysokiej wydajności i bezpieczeństwa na prywatnej, dedykowanej infrastrukturze. Twoje środowisko jest odizolowane i chronione.

Oszczędzaj czas i upraszczaj swój workflow: Twój kod może działać na Python cloud hosting Stackhero już w 5 minut.

Ten przewodnik pokazuje, jak stworzyć proste REST API z użyciem Pythona i Flask. Flask to lekki mikroframework, który umożliwia szybkie budowanie aplikacji webowych i API.

Wymagania wstępne

Przed rozpoczęciem upewnij się, że masz zainstalowane następujące narzędzia:

Python
pip
git
asdf

Jeśli potrzebujesz pomocy przy konfiguracji środowiska, zobacz przewodnik Development platform. Alternatywnie możesz zacząć kodować natychmiast na platformie online Code-Hero. Code-Hero udostępnia IDE oraz terminal online z preinstalowanymi wszystkimi niezbędnymi narzędziami. Dzięki temu możesz skupić się na kodzie, zamiast na instalacji i konfiguracji.

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

Tworzenie nowego projektu

Rozpocznij od utworzenia nowego katalogu projektu. W tym przykładzie projekt nazywa się myRestApi:

mkdir myRestApi
cd myRestApi

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"

Instalacja zależności Flask

Do tego przykładu potrzebujesz jednej głównej zależności: Flask.

Flask został zaprojektowany jako prosty i szybki framework, dzięki czemu możesz budować i wdrażać webowe API bez zbędnych narzutów. Oferuje wbudowane wsparcie dla routingu, szablonów oraz obsługi żądań HTTP, co pozwala przejść od pomysłu do działającego API w kilka minut.

Możesz zainstalować Flask oraz python-dotenv za pomocą pip:

pip install Flask python-dotenv

Dołączamy python-dotenv, aby wygodnie i bezpiecznie zarządzać zmiennymi środowiskowymi. Zobaczysz jego zastosowanie w kolejnych krokach.

Po instalacji zamroź zależności do pliku requirements.txt:

pip freeze > requirements.txt

Zamrożenie zależności zapewnia, że wszyscy korzystają z tych samych wersji pakietów. Ten drobny krok może zaoszczędzić wiele godzin rozwiązywania problemów w przyszłości.

Implementacja REST API z użyciem Flask

Teraz możesz napisać kod swojego API.

Utwórz plik o nazwie app.py i dodaj poniższy kod:

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

# Ładowanie zmiennych środowiskowych z .env dla środowisk innych niż produkcyjne
if os.environ.get('ENV') != 'production':
    load_dotenv()

app = Flask(__name__)

# Przykładowe dane zadań
tasks = [
    {
        'id': 1,
        'title': 'Buy groceries',
        'description': 'Milk, Cheese, Pizza, Fruits',
        'done': False
    },
    {
        'id': 2,
        'title': 'Learn Python',
        'description': 'Learn Python programming basics',
        'done': False
    }
]

@app.route('/api/tasks', methods=['GET'])
def get_tasks():
    return jsonify({'tasks': tasks})

@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 not task:
        return jsonify({'error': 'Task not found'}), 404
    return jsonify({'task': task[0]})

@app.route('/api/tasks', methods=['POST'])
def create_task():
    if not request.json or 'title' not in request.json:
        return jsonify({'error': 'Title is required'}), 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

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

Serwer możesz uruchomić poleceniem:

python app.py

Dzięki host='0.0.0.0' Twoje API jest dostępne przez przeglądarkę podczas korzystania z Code-Hero. Odwiedź http://<XXXXXX>.stackhero-network.com:8080/api/tasks, zamieniając <XXXXXX> na swoją domenę Code-Hero.

Testowanie REST API

Po uruchomieniu serwera możesz komunikować się z API za pomocą cURL. Oto przykładowe polecenia:

Pobierz wszystkie zadania:

curl -s http://localhost:8080/api/tasks
# Output:
# {
#   "tasks": [
#     ...
#   ]
# }

Pobierz konkretne zadanie (ID 2):

curl -s http://localhost:8080/api/tasks/2
# Output:
# {
#   "task": {
#     ...
#   }
# }

Utwórz nowe zadanie:

curl -s -X POST -H "Content-Type: application/json" \
-d '{"title": "New task", "description": "Created with cURL"}' \
http://localhost:8080/api/tasks
# Output:
# {
#   "task": {
#     ...
#   }
# }

Wskazówka: Aby uzyskać czytelniejszy wynik, możesz przekierować rezultat do jq. Na przykład curl -s http://localhost:8080/api/tasks/2 | jq sprawi, że JSON będzie łatwiejszy do odczytania.

Przykład Python REST API z Flask, uruchomionego w Stackhero Code-Hero, z serwerem (1) i klientem korzystającym z cURL (2)

Zarządzanie zmiennymi środowiskowymi

Zmiennie środowiskowe pomagają chronić poufne dane, takie jak hasła do baz danych czy klucze API. Dzięki nim wrażliwe informacje nie trafiają do kodu źródłowego ani historii Git, a także umożliwiają łatwe stosowanie różnych ustawień w zależności od środowiska.

Do zarządzania zmiennymi środowiskowymi możesz użyć modułu python-dotenv. Jeśli pominąłeś wcześniejszą instalację, możesz zrobić to teraz:

pip install python-dotenv
pip freeze > requirements.txt

Utwórz plik .env w katalogu głównym projektu i dodaj zmienne środowiskowe dla środowiska developerskiego:

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

Dodaj .env do .gitignore, aby nie został dodany do repozytorium Git:

echo ".env" >> .gitignore

Do tych zmiennych możesz uzyskać dostęp w Pythonie za pomocą os.environ.get():

import os

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

Plik .env służy wyłącznie do developmentu. W środowisku produkcyjnym lub staging możesz ustawić zmienne środowiskowe bezpośrednio w panelu Stackhero w konfiguracji swojej usługi Python.

Przygotowanie Pythona i Flask do wdrożenia produkcyjnego

Wbudowany serwer Flask jest świetny do developmentu. W produkcji zaleca się użycie wydajnego serwera WSGI, takiego jak Gunicorn. Oto jak się przygotować:

Zainstaluj Gunicorn:

pip install gunicorn
pip freeze > requirements.txt

Uruchom aplikację za pomocą Gunicorn:
```
ENV=production gunicorn app:app \
  --error-logfile - \
  -b 0.0.0.0:8080
```
Tutaj app:app odnosi się do pliku (app.py) oraz instancji aplikacji Flask (app).

Możesz dodać plik Makefile, aby łatwo przełączać się między trybem development a produkcją:

.DEFAULT_GOAL := dev

# Stackhero for Python domyślnie uruchamia regułę "run". Nadpisujemy ją, aby uruchamiała 'prod'.
run: prod

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

dev:
	python app.py

Serwer możesz uruchomić w trybie developerskim poleceniem make dev (lub po prostu make), a w trybie produkcyjnym poleceniem make prod.

Wdrażanie kodu Python do produkcji

Stackhero upraszcza i zabezpiecza wdrożenia w chmurze. Możesz wdrożyć swój projekt Python za pomocą usługi Python cloud hosting. Funkcje obejmują:

Wdrażanie za pomocą jednego git push
Automatyczny TLS (HTTPS) z możliwością konfiguracji domen
Dedykowana infrastruktura dla bezpieczeństwa
Obsługa HTTP/2, TLS 1.3, WebSockets, GZIP & Brotli, ETag oraz dostęp do portów TCP/UDP

Konfiguracja usługi "Stackhero for Python"

Aby wdrożyć, wykonaj następujące kroki:

Pobierz swój publiczny klucz SSH:
```
cat ~/.ssh/id_*.pub
```
W panelu Stackhero otwórz usługę "Stackhero for Python" i wybierz "Configure".
Wklej swój klucz publiczny w polu "SSH public keys" lub "Key".
Kliknij "Validate", aby potwierdzić konfigurację.

Konfiguracja klucza publicznego dla "Stackhero for Python"

Jeśli nie masz jeszcze kluczy SSH, możesz je wygenerować poleceniem:
ssh-keygen -t ed25519

Dodaj zdalne repozytorium Git do swojego projektu za pomocą polecenia podanego w usłudze Stackhero (zamień <XXXXXX> na domenę swojej usługi):

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

Polecenie Git remote

Wdrażanie do produkcji

Gdy jesteś gotowy do wdrożenia, wypchnij kod poleceniem:

git push stackhero main

Pamiętaj, aby zatwierdzić zmiany przed wdrożeniem. W Stackhero Code-Hero możesz użyć Command Palette (Ctrl+Shift+P lub Cmd+Shift+P) i wpisać Git: Commit, aby szybko wykonać commit.

Po wdrożeniu Twoje API będzie dostępne pod adresem https://<XXXXXX>.stackhero-network.com/api/tasks. Zamień <XXXXXX> na domenę swojej usługi, aby uzyskać dostęp do API Flask.

Podsumowanie

Masz już działające REST API zbudowane z Flask. Na tej bazie możesz łatwo rozbudować aplikację, podłączyć bazę danych lub zintegrować z innymi usługami. Flask daje elastyczność, by przejść od prostego prototypu do pełnoprawnego API produkcyjnego.