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
try_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- ... more
generate_helper
...
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!