Python server – jak uruchomić prosty serwer HTTP w Pythonie

1. Co to jest prosty serwer HTTP w Pythonie?

Serwer HTTP to program nasłuchujący na porcie (np. 8000) i odpowiadający na żądania przeglądarki (GET, POST itd.).

Tu przeczytasz

1. Co to jest prosty serwer HTTP w Pythonie?
2. Wymagania wstępne
3. Najszybszy sposób: python -m http.server
4. Automatyzacja – własne polecenie w terminalu (macOS / Linux)
5. Prosty serwer HTTP jako skrypt Pythona
6. Własne odpowiedzi – własny handler
7. Serwer HTTP „od zera” na gniazdach (socket)
8. Prosty serwer z Flask – krok do „prawdziwej” aplikacji WWW
9. Kiedy który sposób wybrać?
10. Bezpieczeństwo i produkcja – ważne zastrzeżenie

Python ma wbudowany moduł http.server, który pozwala m.in. szybko wystawić katalog jako mini‑stronę www (listing plików, pliki statyczne) oraz zwrócić własną treść (np. „Hello, world!”) lub dane dynamiczne.

W praktyce są trzy poziomy „prostego serwera”:

Bez kodu – python -m http.server;
Krótki skrypt – kilka linijek z http.server;
Framework – np. Flask dla wygodniejszego tworzenia aplikacji webowych.

2. Wymagania wstępne

Przed startem upewnij się, że spełniasz poniższe warunki:

zainstalowany Python 3,
w systemie Linux/macOS Python 3 często jest domyślnie dostępny,
na Windows pobierzesz instalator z python.org (łatwo znaleźć),
umiejętność otwarcia terminala/wiersza poleceń,
w Windows użyj „Wiersz polecenia” lub „PowerShell”,
w macOS użyj aplikacji „Terminal”,
w Linux użyj dowolnego emulatora terminala.

Sprawdź wersję Pythona poleceniem:

python --version python3 --version

3. Najszybszy sposób: `python -m http.server`

3.1. Uruchomienie serwera w aktualnym katalogu

Otwórz terminal.
Przejdź do katalogu, który chcesz „wystawić” (np. z plikami HTML):

cd /ścieżka/do/twojego/katalogu

Uruchom serwer poleceniem:

# Python 3 – zalecane python -m http.server 8000

# lub, jeśli system używa nazwy "python3":
python3 -m http.server 8000

Port 8000 możesz zmienić (np. na 8080), jeśli jest zajęty. W Pythonie 2.x używano modułu SimpleHTTPServer, dziś standardem jest Python 3 i http.server.

Otwórz przeglądarkę i wpisz adres:

http://127.0.0.1:8000 albo http://localhost:8000. Zobaczysz listę plików w katalogu lub – jeśli jest index.html – wyświetli się strona.

To ta sama idea, którą wykorzystywała komenda python -m SimpleHTTPServer 8080 w Pythonie 2 – serwer udostępnia pliki z folderu, w którym został uruchomiony.

3.2. Zatrzymanie serwera

W terminalu, gdzie działa serwer, naciśnij:

CTRL + C

To standardowy sposób przerywania procesu w konsoli.

3.3. Dostęp z innych urządzeń w sieci lokalnej

Domyślnie serwer nasłuchuje na 0.0.0.0 (wszystkie interfejsy). Sprawdź lokalny adres IP komputera (np. 192.168.0.10), a następnie na innym urządzeniu w tej samej sieci otwórz adres:

http://192.168.0.10:8000

To wygodny sposób na szybkie udostępnienie plików między komputerem a telefonem w tej samej sieci Wi‑Fi.

4. Automatyzacja – własne polecenie w terminalu (macOS / Linux)

Możesz dodać w powłoce funkcję serv, aby uruchamiać serwer jednym słowem:

Otwórz terminal.
Przejdź do katalogu domowego:

cd ~

Otwórz plik konfiguracyjny powłoki (np. ~/.bash_profile lub ~/.bashrc):

nano .bash_profile

Wklej na końcu pliku funkcję:

serv() { python -m http.server ${1:-8080} }

Zapisz i wyjdź (w nano: Ctrl+O, Enter, potem Ctrl+X).
Zrestartuj terminal lub załaduj plik:

source ~/.bash_profile

Od teraz używaj poleceń:

cd /folder/z/plikami serv # serwer na porcie 8080 serv 8000 # serwer na porcie 8000

5. Prosty serwer HTTP jako skrypt Pythona

Moduł wbudowany możesz wykorzystać w własnym pliku .py – zyskasz większą kontrolę nad konfiguracją. Utwórz plik server.py z treścią:

from http.server import HTTPServer, SimpleHTTPRequestHandler

PORT = 8000

if __name__ == "__main__":
server_address = ("", PORT) # "" = nasłuchuj na wszystkich interfejsach
httpd = HTTPServer(server_address, SimpleHTTPRequestHandler)
print(f"Serwer HTTP działa na porcie {PORT}. Wejdź na http://localhost:{PORT}")
try:
httpd.serve_forever()
except KeyboardInterrupt:
print("\nZatrzymywanie serwera...")
httpd.server_close()

Uruchom skrypt poleceniem:

python server.py

Ten kod tworzy serwer działający podobnie jak python -m http.server – serwuje pliki z katalogu, w którym uruchomiono skrypt.

6. Własne odpowiedzi – własny handler

Jeśli chcesz, by serwer zwracał konkretną treść zamiast listy plików, nadpisz metodę do_GET w BaseHTTPRequestHandler. Poniższy przykład dodaje prosty routing:

6.1. Serwer „Hello, world” z obsługą ścieżek

from http.server import BaseHTTPRequestHandler, HTTPServer

class MyHandler(BaseHTTPRequestHandler):
def do_GET(self):
# Prosty routing po ścieżkach URL
if self.path == "/" or self.path == "/index":
self.handle_index()
elif self.path == "/hello":
self.handle_hello()
else:
self.handle_404()

def handle_index(self):
content = "<h1>Witaj na prostym serwerze HTTP w Pythonie</h1>"
self._send_response(200, content)

def handle_hello(self):
content = "<h1>Hello, world!</h1><p>To jest odpowiedź z własnego handlera.</p>"
self._send_response(200, content)

def handle_404(self):
content = "<h1>404 - Nie znaleziono</h1>"
self._send_response(404, content)

def _send_response(self, status_code, content, content_type="text/html; charset=utf-8"):
# Nagłówek statusu
self.send_response(status_code)
# Nagłówki HTTP
self.send_header("Content-Type", content_type)
self.send_header("Content-Length", str(len(content.encode("utf-8"))))
self.end_headers()
# Treść odpowiedzi (body)
self.wfile.write(content.encode("utf-8"))

def run_server(port=8000):
server_address = ("", port)
httpd = HTTPServer(server_address, MyHandler)
print(f"Serwer działa na http://localhost:{port} (CTRL+C aby przerwać)")
try:
httpd.serve_forever()
except KeyboardInterrupt:
print("\nZatrzymywanie serwera...")
httpd.server_close()

if __name__ == "__main__":
run_server(8000)

Uruchom serwer poleceniem:

python server_custom.py

Dostępne trasy po uruchomieniu:

http://localhost:8000/ → prosta strona powitalna,
http://localhost:8000/hello → komunikat „Hello, world!”,
inne ścieżki → kod odpowiedzi 404.

Taki serwer nadal jest prosty, ale pozwala już tworzyć osobne „endpointy” jak w większych aplikacjach webowych.

7. Serwer HTTP „od zera” na gniazdach (socket)

Dla pełnego zrozumienia możesz napisać serwer HTTP bezpośrednio na gniazdach (socket). Oto minimalny przykład:

7.1. Bardzo prosty serwer na `socket`

import socket

HOST = "0.0.0.0" # nasłuchuj na wszystkich interfejsach
PORT = 8000

response_body = """\
<html>
<head><title>Prosty serwer socket</title></head>
<body>
<h1>Witaj!</h1>
<p>To odpowiedź z serwera HTTP napisanego na gniazdach.</p>
</body>
</html>
"""

response = f"""\
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: {len(response_body.encode("utf-8"))}

{response_body}
"""

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((HOST, PORT))
s.listen(1)
print(f"Serwer socket HTTP działa na http://localhost:{PORT}")
while True:
client_socket, client_address = s.accept()
with client_socket:
request = client_socket.recv(1024).decode("utf-8", errors="ignore")
print("Otrzymano żądanie:\n", request.splitlines())
client_socket.sendall(response.encode("utf-8"))

Ten kod:

tworzy gniazdo TCP,
nasłuchuje na porcie 8000,
przyjmuje połączenia,
ignoruje treść żądania i zawsze zwraca tę samą stronę.

8. Prosty serwer z Flask – krok do „prawdziwej” aplikacji WWW

Jeżeli chcesz od razu pisać aplikację z wieloma widokami, szablonami HTML, formularzami itd., wygodniej jest użyć frameworka Flask. To lekka biblioteka, która upraszcza tworzenie endpointów.

8.1. Instalacja (zalecane środowisko wirtualne)

Wykonaj poniższe kroki:

Utwórz katalog projektu i przejdź do niego:

mkdir moj_flask cd moj_flask

Utwórz środowisko wirtualne:

python -m venv venv # lub: python3 -m venv venv

Aktywuj środowisko w zależności od systemu:

w Windows (PowerShell): .\venv\Scripts\Activate.ps1,
w Windows (cmd): venv\Scripts\activate.bat,
w macOS/Linux: source venv/bin/activate.

Zainstaluj Flask:

pip install Flask

8.2. Pierwszy serwer Flask – „hello, world!”

Utwórz plik app.py z treścią:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def index():
return "Hello, World! To jest prosty serwer Flask w Pythonie."

@app.route("/hello/<name>")
def hello(name):
return f"Witaj, {name}!"

if __name__ == "__main__":
app.run(debug=True) # domyślnie: http://127.0.0.1:5000

Uruchom aplikację poleceniem:

python app.py

W terminalu zobaczysz komunikat w stylu: „Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)”. Otwórz w przeglądarce http://127.0.0.1:5000/ lub np. http://127.0.0.1:5000/hello/Ala.

8.3. Szablony HTML (katalog `templates`)

Utwórz katalog na szablony:

mkdir templates

Dodaj plik templates/index.html z treścią:

<!doctype html> <html lang="pl"> <head> <meta charset="utf-8"> <title>Prosty serwer Flask</title> </head> <body> <h1>Witaj, {{ imie }}!</h1> <p>To strona wygenerowana z szablonu Jinja2.</p> </body> </html>

Zmień app.py, aby użyć szablonu:

from flask import Flask, render_template

app = Flask(__name__)

@app.route("/")
def index():
return render_template("index.html", imie="Czytelniku")

if __name__ == "__main__":
app.run(debug=True)

Po odświeżeniu strony zobaczysz HTML generowany z szablonu Jinja2.

9. Kiedy który sposób wybrać?

Dobierz rozwiązanie do potrzeb:

Potrzeba / scenariusz	Rozwiązanie w Pythonie
szybkie udostępnienie plików (HTML, zdjęcia, PDF) w sieci lokalnej	`python -m http.server` w katalogu z plikami
prosta demonstracja HTTP, nauka, mały test bez frameworków	własny skrypt z `http.server` lub `socket`
tworzenie prostej aplikacji web (wiele endpointów, szablony)	Flask (ew. inne frameworki: FastAPI, Django)
nauka protokołu i niskopoziomowego działania sieci	ręczny serwer na `socket` (jak w przykładzie powyżej)