Verbeter mijn Git CI/CD Integratie voor Automatisering van Versiebeheer
description
Met deze prompt krijg je stap-voor-stap advies om Git te koppelen aan CI/CD pipelines, waardoor je softwareontwikkeling sneller, betrouwbaarder en minder foutgevoelig wordt. Het helpt je handmatige taken te automatiseren en een efficiëntere releasecyclus te realiseren dan traditionele workflows.
prompt
Help me een Git CI/CD pipeline op te zetten voor mijn projecttype: <voer je projecttype in>. Leg uit hoe ik Git kan integreren met CI/CD-tools om mijn build-, test- ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hieronder geef ik een overzicht en praktische voorbeelden om een CI/CD-pipeline voor je Python microservices met Docker en Kubernetes op te zetten, inclusief integratie met Git en best practices.
1. **Versiebeheer en Git-integratie**
Gebruik een Git-hostingplatform zoals GitHub, GitLab of Bitbucket. Zorg dat je repository goed gestructureerd is, bijvoorbeeld:
```
/app
/docker
/k8s
/.gitlab-ci.yml (of .github/workflows/ci.yml)
```
2. **CI/CD Tools kiezen**
Voor CI/CD kun je tools gebruiken zoals GitLab CI, GitHub Actions, Jenkins, of CircleCI. Hier focus ik op GitLab CI en GitHub Actions als voorbeelden.
3. **Automatiseringstaken**
- **Build:** Maak een Docker-image van je microservice.
- **Test:** Voer Python-unittests en integratietests uit.
- **Push:** Push Docker-image naar een registry (bijvoorbeeld Docker Hub of GitLab Container Registry).
- **Deploy:** Update Kubernetes met het nieuwe image.
4. **Voorbeeldconfiguratie: GitLab CI/CD**
Maak een `.gitlab-ci.yml` in je repo:
```yaml
stages:
- test
- build
- push
- deploy
variables:
IMAGE_TAG: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA
before_script:
- echo "Authenticatie met registry"
- docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" $CI_REGISTRY
test:
stage: test
image: python:3.11
script:
- pip install -r requirements.txt
- pytest tests/
build:
stage: build
image: docker:latest
services:
- docker:dind
script:
- docker build -t $IMAGE_TAG ./docker
only:
- main
push:
stage: push
image: docker:latest
services:
- docker:dind
script:
- docker push $IMAGE_TAG
only:
- main
deploy:
stage: deploy
image: bitnami/kubectl:latest
script:
- kubectl set image deployment/my-microservice my-microservice=$IMAGE_TAG -n mijn-namespace
- kubectl rollout status deployment/my-microservice -n mijn-namespace
only:
- main
```
**Uitleg:**
- `test` voert Python-tests uit.
- `build` maakt een Docker-image.
- `push` pusht het image naar de registry.
- `deploy` update de Kubernetes deployment met het nieuwe image.
5. **Voorbeeldconfiguratie: GitHub Actions**
Maak `.github/workflows/ci.yml`:
```yaml
name: CI/CD Workflow
on:
push:
branches:
- main
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Set up Python
uses: actions/setup-python@v4
with:
python-version: '3.11'
- name: Install dependencies
run: pip install -r requirements.txt
- name: Run Tests
run: pytest tests/
build_and_push:
needs: test
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Log in to DockerHub
uses: docker/login-action@v2
with:
username: ${{ secrets.DOCKER_USERNAME }}
password: ${{ secrets.DOCKER_PASSWORD }}
- name: Build Docker Image
run: |
docker build -t mydockerhubuser/myservice:${{ github.sha }} ./docker
- name: Push Docker Image
run: |
docker push mydockerhubuser/myservice:${{ github.sha }}
deploy:
needs: build_and_push
runs-on: ubuntu-latest
steps:
- name: Deploy to Kubernetes
uses: azure/k8s-deploy@v2
with:
manifests: k8s/deployment.yaml
images: |
mydockerhubuser/myservice:${{ github.sha }}
kubectl-version: 'latest'
env:
KUBECONFIG: ${{ secrets.KUBECONFIG }}
```
**Uitleg:**
- De workflow draait bij elke push naar `main`.
- Teststap voert Python-tests uit.
- Build- en push-stappen maken en pushen het Docker-image.
- Deploy-stap update de Kubernetes deployment.
6. **Best practices**
- **Automatiseer alles:** zorg dat build, test, en deployment automatisch verlopen.
- **Gebruik versies en tags:** tag images met commit-SHA of versienummers.
- **Beveilig je secrets:** sla wachtwoorden en kubeconfig veilig op in secrets.
- **Rollback mogelijkheden:** gebruik `kubectl rollout undo` voor snelle herstel.
- **Continuous feedback:** monitor build- en deployfouten en integreer notificaties.
- **Kleine, frequente deployments:** minimaliseer risico en verbeter snel feedback.
7. **Samenvatting**
- Gebruik Git voor versiebeheer en integratie.
- Stel CI/CD pipelines in met tools als GitLab CI of GitHub Actions.
- Automatiseer build, test, push en deploy stappen.
- Gebruik Docker voor containerisatie en Kubernetes voor orkestratie.
- Volg best practices voor betrouwbaarheid en veiligheid.
Wil je hulp bij het aanpassen van de configuraties voor jouw specifieke project of meer details over een bepaald onderdeel?
provider: deepseek
model: deepseek-chat
Zeker! Ik help je bij het opzetten van een CI/CD-pipeline voor Python microservices met Docker en Kubernetes. Hier is een complete handleiding met praktische voorbeelden.
## 1. Keuze van CI/CD Tool
Populaire opties voor jouw stack:
- **GitHub Actions** (aanbevolen voor GitHub repos)
- **GitLab CI/CD**
- **Jenkins**
- **ArgoCD** (voor GitOps op Kubernetes)
## 2. Basis Pipeline Structuur
### GitHub Actions Voorbeeld (`.github/workflows/ci-cd.yml`):
```yaml
name: Python Microservice CI/CD
on:
push:
branches: [ main, develop ]
pull_request:
branches: [ main ]
jobs:
test:
runs-on: ubuntu-latest
strategy:
matrix:
python-version: ['3.9', '3.10', '3.11']
steps:
- uses: actions/checkout@v4
- name: Set up Python ${{ matrix.python-version }}
uses: actions/setup-python@v4
with:
python-version: ${{ matrix.python-version }}
- name: Install dependencies
run: |
python -m pip install --upgrade pip
pip install -r requirements.txt
pip install pytest pytest-cov
- name: Run tests with coverage
run: |
pytest --cov=src --cov-report=xml tests/
- name: Upload coverage to Codecov
uses: codecov/codecov-action@v3
with:
file: ./coverage.xml
build-and-push:
needs: test
runs-on: ubuntu-latest
if: github.ref == 'refs/heads/main'
steps:
- uses: actions/checkout@v4
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v2
- name: Log in to Docker Hub
uses: docker/login-action@v2
with:
username: ${{ secrets.DOCKER_USERNAME }}
password: ${{ secrets.DOCKER_PASSWORD }}
- name: Build and push Docker image
uses: docker/build-push-action@v4
with:
context: .
push: true
tags: |
yourusername/your-microservice:latest
yourusername/your-microservice:${{ github.sha }}
cache-from: type=gha
cache-to: type=gha,mode=max
deploy:
needs: build-and-push
runs-on: ubuntu-latest
if: github.ref == 'refs/heads/main'
steps:
- uses: actions/checkout@v4
- name: Set up kubectl
uses: azure/setup-kubectl@v3
with:
version: 'latest'
- name: Deploy to Kubernetes
env:
KUBE_CONFIG: ${{ secrets.KUBE_CONFIG }}
run: |
echo "$KUBE_CONFIG" > kubeconfig.yaml
kubectl --kubeconfig=kubeconfig.yaml apply -f kubernetes/deployment.yaml
kubectl --kubeconfig=kubeconfig.yaml rollout status deployment/your-microservice
```
## 3. Docker Bestand Voorbeeld (`Dockerfile`)
```dockerfile
FROM python:3.11-slim
WORKDIR /app
# Install system dependencies
RUN apt-get update && apt-get install -y \
build-essential \
curl \
&& rm -rf /var/lib/apt/lists/*
# Copy requirements and install Python dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Copy application code
COPY src/ ./src/
COPY app.py .
# Create non-root user
RUN useradd --create-home --shell /bin/bash appuser
USER appuser
# Expose port
EXPOSE 8000
# Health check
HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
CMD curl -f http://localhost:8000/health || exit 1
# Run the application
CMD ["python", "-m", "src.main"]
```
## 4. Kubernetes Deployment (`kubernetes/deployment.yaml`)
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: your-microservice
namespace: production
spec:
replicas: 3
selector:
matchLabels:
app: your-microservice
template:
metadata:
labels:
app: your-microservice
spec:
containers:
- name: your-microservice
image: yourusername/your-microservice:latest
imagePullPolicy: Always
ports:
- containerPort: 8000
env:
- name: ENVIRONMENT
value: "production"
- name: DATABASE_URL
valueFrom:
secretKeyRef:
name: database-secrets
key: connection-string
resources:
requests:
memory: "256Mi"
cpu: "250m"
limits:
memory: "512Mi"
cpu: "500m"
livenessProbe:
httpGet:
path: /health
port: 8000
initialDelaySeconds: 30
periodSeconds: 10
readinessProbe:
httpGet:
path: /health
port: 8000
initialDelaySeconds: 5
periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
name: your-microservice-service
namespace: production
spec:
selector:
app: your-microservice
ports:
- port: 80
targetPort: 8000
type: ClusterIP
```
## 5. Best Practices en Tips
### Security:
```yaml
# In je Dockerfile
RUN pip install --no-cache-dir --user -r requirements.txt && \
rm -rf /root/.cache/pip
```
### Multi-stage Builds:
```dockerfile
FROM python:3.11-slim as builder
RUN pip install --user pipenv
COPY Pipfile Pipfile.lock ./
RUN pipenv install --deploy --ignore-pipfile
FROM python:3.11-slim
COPY --from=builder /root/.local/share/virtualenvs /app/venv
ENV PATH="/app/venv/bin:$PATH"
```
### Environment Management:
```yaml
# .github/workflows/ci-cd.yml
env:
DOCKER_IMAGE: yourusername/your-microservice
K8S_NAMESPACE: ${{ github.ref == 'refs/heads/main' && 'production' || 'staging' }}
```
### Dependency Caching:
```yaml
- name: Cache Python dependencies
uses: actions/cache@v3
with:
path: ~/.cache/pip
key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
restore-keys: |
${{ runner.os }}-pip-
```
## 6. Geavanceerde Configuraties
### Canary Deployment:
```yaml
# canary-deployment.yaml
apiVersion: flagger.app/v1beta1
kind: Canary
metadata:
name: your-microservice
spec:
targetRef:
apiVersion: apps/v1
kind: Deployment
name: your-microservice
service:
port: 8000
analysis:
interval: 1m
threshold: 5
maxWeight: 50
stepWeight: 10
```
### Autoscaling:
```yaml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: your-microservice-hpa
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: your-microservice
minReplicas: 2
maxReplicas: 10
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 70
```
## 7. Monitoring en Logging
Voeg deze toe aan je requirements.txt:
```
prometheus-client==0.17.1
structlog==23.1.0
```
## 8. Secrets Management
Gebruik Kubernetes Secrets of external secret managers:
```bash
# GitHub Secrets instellen
DOCKER_USERNAME=yourusername
DOCKER_PASSWORD=yourpassword
KUBE_CONFIG=base64-encoded-kubeconfig
```
Dit setup biedt een solide basis voor je Python microservices. Pas de configuraties aan op basis van je specifieke requirements en infrastructure!