W tym artykule pokażę Ci, jak w kilka minut wdrożyć aplikację webową na lokalnym klastrze K8s przy pomocy MicroK8s.
Zbudujemy prostą aplikację webową (uploader plików) w Pythonie, przygotujemy obraz Dockera, opublikujemy go w lokalnym rejestrze i wdrożymy w Kubernetesie.
Ten przewodnik jest idealny dla:
- użytkowników Linuxa,
- developerów chcących testować aplikacje w wiernie odzwierciedlonym środowisku K8s bez konieczności używania chmury,
- zespołów DevOps rozpoczynających pracę z K8s,
- każdego, kto chce szybko stworzyć lokalne środowisko Kubernetes do celów edukacyjnych lub testowych.
Dlaczego Microk8s, a nie Docker Desktop?
Dlaczego warto rozważyć wykorzystanie MicroK8s zamiast Docker Desktop? Z kilku powodów:
- jest lżejsze i szybsze – Microk8s zużywa mniej zasobów (CPU/RAM) – nawet 500 MB, w porównaniu do 4+ GB,
- jest darmowe, open-source,
- prostsza/wierniejsza konfiguracja wielu komponentów K8s.
Wykonamy:
- instalacje i konfiguracje Microk8s, Dockera oraz Docker Registry,
- aplikację webową umożliwiającą przesyłanie plików (file uploader),
- obraz Dockera z aplikacją,
- klastrowe środowisko MicroK8s z PVC (PersistentVolumeClaim),
- deployment i service w Kubernetesie dostępne przez NodePort.
Czym jest MicroK8s?
MicroK8s to lekka dystrybucja Kubernetes stworzona przez Canonical (twórców Ubuntu). Idealna do lokalnego developmentu, testów CI/CD oraz PoC-ów. Nie wymaga dużych zasobów i działa dobrze w różnych środowiskach.
Potrzebujesz:
- Python 3.x (dla aplikacji),
- Docker,
- MicroK8s,
- Podstawowe narzędzia CLI: kubectl, curl, git.
Instalacja Dockera
# Docker
sudo apt update
sudo apt install -y docker.io
# Kubectl (jeśli nie używasz wersji z MicroK8s)
sudo apt install -y kubectl curl git
Instalacja i konfiguracja MicroK8s
Instalacja MicroK8s:
sudo snap install microk8s –classic
Nadanie uprawnień: dodaj użytkownika do grupy Microk8s, aby uniknąć konieczności używania sudo:
sudo usermod -a -G microk8s $USER
newgrp microk8s
Sprawdzenie statusu:
microk8s status --wait-ready
Aktywacja wbudowanego registry
MicroK8s oferuje wbudowany lokalny rejestr Dockerowy:
microk8s enable registry
Domyślnie działa na localhost:32000.
Kodowanie
Tworzymy pliki o poniższym schemacie:
# uploader.py
from flask import Flask, request
import os
app = Flask(__name__)
UPLOAD_FOLDER = os.getenv('UPLOAD_FOLDER', 'uploads')
os.makedirs(UPLOAD_FOLDER, exist_ok=True)
@app.route('/', methods=['GET', 'POST'])
def upload_file():
if request.method == 'POST':
f = request.files['file']
f.save(os.path.join(UPLOAD_FOLDER, f.filename))
return 'File uploaded!'
return '''
<form method="post" enctype="multipart/form-data">
<input type="file" name="file">
<input type="submit">
</form>
'''
if __name__ == '__main__':
app.run(host='0.0.0.0', port=8080)
# Dockerfile
FROM python:3.11-slim
WORKDIR /app
. .
RUN pip install -r requirements.txt
EXPOSE 8080
ENV UPLOAD_FOLDER=/data/uploads
RUN mkdir -p ${UPLOAD_FOLDER}
CMD ["python", "uploader.py"]
# requirements.txt
flask
# deployment.yaml
apiVersion: v1
kind: PersistentVolume
metadata:
name: uploader-pv
spec:
capacity:
storage: 1Gi
accessModes:
- ReadWriteOnce
storageClassName: manual
hostPath:
path: "/tmp/uploader-data"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: uploader-pvc
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 1Gi
storageClassName: manual
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: file-uploader
spec:
replicas: 1
selector:
matchLabels:
app: file-uploader
template:
metadata:
labels:
app: file-uploader
spec:
containers:
- name: uploader
image: localhost:32000/file-uploader:latest
ports:
- containerPort: 8080
volumeMounts:
- name: uploader-storage
mountPath: /data
env:
- name: UPLOAD_FOLDER
value: "/data/uploads"
volumes:
- name: uploader-storage
persistentVolumeClaim:
claimName: uploader-pvc
---
apiVersion: v1
kind: Service
metadata:
name: uploader-service
spec:
type: NodePort
selector:
app: file-uploader
ports:
- port: 8080
targetPort: 8080
nodePort: 30001
Tworzymy obraz i publikujemy go lokalnie
Zakładając, że pliki uploader.py, Dockerfile i requirements.txt są w katalogu projektu:
# Budowa obrazu
docker build -t file-uploader:latest
# Tagowanie do lokalnego registry
docker tag file-uploader localhost:32000/file-uploader
# Push do MicroK8s registry
docker push localhost:32000/file-uploader
Wdrożenie:
microk8s kubectl apply -f deployment.yaml
Sprawdź, czy wszystko działa:
microk8s kubectl get pods
microk8s kubectl get svc
Dostęp do aplikacji – po uruchomieniu aplikacji, będzie ona dostępna w przeglądarce pod adresem:
http://localhost:30001
Podsumowanie
Dzięki zdefiniowanemu PersistentVolume pliki będą zapisywane lokalnie w:
/tmp/uploader-data/uploads/
To pozwala zachować dane między restartami Podów – bardzo przydatne nawet w testowym środowisku.
Dzięki MicroK8s można w ciągu kilku minut przetestować aplikację działającą w Kubernetesie lokalnie, bez potrzeby korzystania z chmury. Wdrożenie jest szybkie, lekkie i powtarzalne – a jednocześnie bliskie rzeczywistej infrastrukturze.
Zostaw komentarz