claudient 0.1.0

package/skills/devops-infra/nl/github-actions.md

@@ -0,0 +1,179 @@
+> 🇳🇱 Dit is de Nederlandse vertaling. [Engelse versie](../github-actions.md).
+
+# GitHub Actions Skill
+
+## Wanneer te activeren
+- CI/CD-pipelines schrijven voor testen, linting, bouwen en deployen
+- Matrix-builds instellen voor meerdere besturingssystemen of taalversies
+- Omgevingsbeschermingsregels en deployment-gates configureren
+- Herbruikbare workflows of composite actions schrijven
+- Docker build instellen en naar een containerregister pushen
+- OIDC-authenticatie naar cloudproviders configureren (geen langlevende secrets)
+- Falende workflows debuggen of workflowsyntaxfouten begrijpen
+- Caching instellen voor afhankelijkheden (npm, pip, Go modules)
+
+## Wanneer NIET te gebruiken
+- GitLab CI, CircleCI, Jenkins — andere pipeline-systemen
+- Lokale ontwikkelingsautomatisering (gebruik Makefile of scripts)
+- Cron-jobs die niet aan een repository zijn gekoppeld (gebruik cloud scheduler)
+
+## Instructies
+
+### Workflow-bestandsstructuur
+```yaml
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+# Expliciete rechten — gebruik nooit de standaard write-all
+permissions:
+  contents: read
+  pull-requests: write    # Alleen als nodig (bijv. voor het plaatsen van opmerkingen)
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+      - run: npm ci
+      - run: npm test
+```
+
+### Rechten — altijd expliciet
+Gebruik nooit de standaard `permissions: write-all`. Declareer altijd minimaal vereiste rechten:
+```yaml
+permissions:
+  contents: read          # Repository lezen
+  packages: write         # Pushen naar GitHub Container Registry
+  id-token: write         # OIDC voor cloud-authenticatie
+  pull-requests: write    # Opmerkingen op PR's plaatsen
+```
+
+### Secrets — OIDC boven langlevende credentials
+Gebruik OIDC (OpenID Connect) voor cloud-authenticatie — geen opgeslagen secrets:
+
+```yaml
+# AWS OIDC — geen AWS_ACCESS_KEY_ID nodig
+- name: Configure AWS credentials
+  uses: aws-actions/configure-aws-credentials@v4
+  with:
+    role-to-assume: arn:aws:iam::123456789:role/github-actions-role
+    aws-region: eu-west-1
+
+# GCP OIDC
+- name: Authenticate to GCP
+  uses: google-github-actions/auth@v2
+  with:
+    workload_identity_provider: projects/123/locations/global/workloadIdentityPools/pool/providers/github
+    service_account: deploy@project.iam.gserviceaccount.com
+```
+
+### Afhankelijkheidscaching
+Cache altijd afhankelijkheden om bouwtijd te verkorten:
+```yaml
+# Node.js
+- uses: actions/setup-node@v4
+  with:
+    node-version: '20'
+    cache: 'npm'          # Ingebouwde cache — geen handmatige cache-stap nodig
+
+# Python
+- uses: actions/setup-python@v5
+  with:
+    python-version: '3.12'
+    cache: 'pip'
+
+# Go
+- uses: actions/setup-go@v5
+  with:
+    go-version: '1.22'
+    cache: true
+```
+
+### Omgevingsgates voor productie-deployments
+```yaml
+jobs:
+  deploy-production:
+    environment: production    # Verwijst naar GitHub Environment met beschermingsregels
+    needs: [test, build]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Deploy
+        run: ./scripts/deploy.sh
+```
+
+Stel omgevingsbeschermingsregels in via GitHub-instellingen:
+- Vereiste reviewers voor productie-deployments
+- Wachttimer tussen staging en productie
+- Beperken tot specifieke branches (alleen `main`)
+
+### Matrix-builds
+```yaml
+jobs:
+  test:
+    strategy:
+      matrix:
+        node-version: [18, 20, 22]
+        os: [ubuntu-latest, windows-latest]
+      fail-fast: false    # Niet alles annuleren bij eerste fout
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+```
+
+### Herbruikbare workflows
+```yaml
+# .github/workflows/deploy.yml — herbruikbaar
+on:
+  workflow_call:
+    inputs:
+      environment:
+        required: true
+        type: string
+    secrets:
+      deploy-token:
+        required: true
+
+# Aanroeper
+jobs:
+  deploy:
+    uses: ./.github/workflows/deploy.yml
+    with:
+      environment: production
+    secrets:
+      deploy-token: ${{ secrets.DEPLOY_TOKEN }}
+```
+
+### Veelvoorkomende fouten
+- `actions/checkout@v4` ontbreekt — altijd de eerste stap
+- Secrets niet toegankelijk in forks — gebruik `pull_request_target` voorzichtig (beveiligingsrisico)
+- Cache niet getroffen — sleutel moet exact overeenkomen; gebruik `restore-keys` als fallback
+- OIDC mislukt — controleer vertrouwensbeleid aan de cloudprovider-kant dat de repo en branch toestaat
+
+## Voorbeeld
+
+**Gebruiker:** Schrijf een CI/CD-pipeline voor een Node.js-app: voer tests uit op PR's, bouw en push Docker image bij merge naar main, deploy naar productie met een handmatige goedkeuringsgate.
+
+**Verwachte output:**
+- `on: push/pull_request`-triggers
+- `test`-job: checkout, setup-node met cache, `npm ci`, `npm test`
+- `build`-job (bij push naar main, heeft test nodig): Docker build + push naar GHCR via OIDC
+- `deploy`-job: `environment: production` (vereist goedkeuring), roept deploy-script aan
+- Expliciet `permissions:`-blok — minimaal vereist
+- Geen hardcoded secrets — OIDC voor registry-authenticatie
+
+---
+
+> **Werk met ons:** Claudient wordt ondersteund door [Uitbreiden](https://uitbreiden.com/) — we bouwen AI-producten en B2B-oplossingen met ontwikkelaarsgemeenschappen. CI/CD bouwen voor AI-producten of cloud-deployments? [uitbreiden.com](https://uitbreiden.com/)

package/skills/devops-infra/nl/kubernetes.md

@@ -0,0 +1,129 @@
+> 🇳🇱 Dit is de Nederlandse vertaling. [Engelse versie](../kubernetes.md).
+
+# Kubernetes Skill
+
+## Wanneer te activeren
+- Kubernetes manifests schrijven (Deployments, Services, ConfigMaps, Secrets, Ingress)
+- Helm charts of values-bestanden configureren voor een applicatie
+- Een falende Pod, CrashLoopBackOff, of OOMKilled container debuggen
+- Horizontal pod autoscaling (HPA) of vertical pod autoscaling (VPA) instellen
+- Resource requests en limits definiëren voor containers
+- RBAC-beleid schrijven of reviewen (Roles, ClusterRoles, RoleBindings)
+- Liveness-, readiness- en startup-probes instellen
+- Persistent volumes en persistent volume claims configureren
+- Network policies schrijven om pod-naar-pod-verkeer te beheren
+- Namespaces en multi-tenant isolatie instellen
+
+## Wanneer NIET te gebruiken
+- Docker Compose-setups die niet naar Kubernetes worden gemigreerd
+- Serverless (Cloud Run, Lambda, Fargate) — ander deployment-model
+- Eenvoudige single-container apps die geen orkestratie nodig hebben
+- Lokale ontwikkelomgevingen waar Docker alleen voldoende is
+- Nomad, Mesos, of andere niet-Kubernetes orchestrators
+
+## Instructies
+
+### Manifest-structuur
+Stel deze velden altijd in voor elke Deployment:
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: app-name
+  namespace: production          # Altijd expliciet — nooit vertrouwen op de default namespace
+  labels:
+    app: app-name
+    version: "1.0.0"
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app: app-name
+  template:
+    metadata:
+      labels:
+        app: app-name
+        version: "1.0.0"
+    spec:
+      containers:
+        - name: app-name
+          image: registry/app-name:tag   # Gebruik nooit :latest in productie
+          resources:
+            requests:
+              cpu: "100m"
+              memory: "128Mi"
+            limits:
+              cpu: "500m"
+              memory: "512Mi"
+```
+
+### Resource requests en limits
+- Stel altijd zowel `requests` als `limits` in — nooit weglaten
+- `requests` = gegarandeerde resources (gebruikt voor scheduling)
+- `limits` = maximaal toegestaan (OOMKilled als geheugen wordt overschreden)
+- CPU-limits zijn optioneel in clusters met CPU-throttling uitgeschakeld — maar geheugenlimieten zijn verplicht
+- Begin conservatief: requests op ~25% van verwacht, limits op 2x verwacht, dan bijstellen met werkelijke metrieken
+
+### Health probes
+Alle productiecontainers moeten probes hebben:
+```yaml
+livenessProbe:
+  httpGet:
+    path: /healthz
+    port: 8080
+  initialDelaySeconds: 15
+  periodSeconds: 20
+  failureThreshold: 3
+
+readinessProbe:
+  httpGet:
+    path: /ready
+    port: 8080
+  initialDelaySeconds: 5
+  periodSeconds: 10
+  failureThreshold: 3
+```
+- `livenessProbe`-fout → container herstart
+- `readinessProbe`-fout → verwijderd uit Service load balancer (geen verkeer, geen herstart)
+- Wijs beide nooit naar hetzelfde endpoint — readiness moet afhankelijkheden controleren, liveness niet
+
+### Secrets-beheer
+- Zet nooit secrets in ConfigMaps — gebruik Secrets
+- Commit nooit Secret-manifests met echte waarden — gebruik sealed-secrets, external-secrets-operator, of Vault
+- Verwijs naar secrets als omgevingsvariabelen, niet als volumes, tenzij de app specifiek bestandsgebaseerde secrets vereist:
+```yaml
+env:
+  - name: DATABASE_URL
+    valueFrom:
+      secretKeyRef:
+        name: app-secrets
+        key: database-url
+```
+
+### Namespace-conventies
+- `default` namespace: alleen voor dev/testing
+- Productie-workloads altijd in benoemde namespaces
+- Gebruik `ResourceQuota` en `LimitRange` op elke productie-namespace
+- RBAC: ontwikkelaars krijgen edit in dev-namespaces, view in productie
+
+### Veelvoorkomende CrashLoopBackOff-oorzaken en oplossingen
+1. Ontbrekende omgevingsvariabele → controleer de sectie Events van `kubectl describe pod`
+2. Mislukte healthcheck → logs tonen de werkelijke fout, probe detecteert alleen
+3. OOMKilled → verhoog de geheugenlimiet of los geheugenlek op
+4. Image pull-fout → controleer imagePullPolicy en registrygegevens
+5. Init container-fout → `kubectl logs pod-name -c init-container-name`
+
+## Voorbeeld
+
+**Gebruiker:** Implementeer een FastAPI-app met PostgreSQL-verbinding, 3 replica's, resource-limieten en health checks.
+
+**Verwachte outputstructuur:**
+- Namespace-manifest
+- Secret voor `DATABASE_URL`
+- Deployment met 3 replica's, resource requests/limits, liveness + readiness probes die verwijzen naar `/healthz` en `/ready`
+- Service (ClusterIP) die port 80 blootstelt → container port 8080
+- HorizontalPodAutoscaler gericht op 70% CPU-gebruik, min 3 / max 10 replica's
+
+---
+
+> **Werk met ons:** Claudient wordt ondersteund door [Uitbreiden](https://uitbreiden.com/) — we bouwen AI-producten en B2B-oplossingen met ontwikkelaarsgemeenschappen. Kubernetes-infrastructuur of cloud-native AI-producten bouwen? [uitbreiden.com](https://uitbreiden.com/)

package/skills/devops-infra/nl/terraform.md

@@ -0,0 +1,130 @@
+> 🇳🇱 Dit is de Nederlandse vertaling. [Engelse versie](../terraform.md).
+
+# Terraform Skill
+
+## Wanneer te activeren
+- Terraform-modules schrijven voor AWS-, GCP- of Azure-infrastructuur
+- VPC's, subnets, security groups en netwerkresources definiëren
+- Compute-resources inrichten (EC2, GKE, AKS, ECS, Lambda)
+- Database-infrastructuur beheren (RDS, Cloud SQL, Aurora)
+- IAM-rollen, -beleid en serviceaccounts instellen
+- Remote state-configuratie schrijven (S3 backend, GCS, Terraform Cloud)
+- Bestaande Terraform refactoren om modules te gebruiken
+- CI/CD-pipelines schrijven voor `terraform plan` en `terraform apply`
+- Bestaande infrastructuur importeren in de Terraform-state
+
+## Wanneer NIET te gebruiken
+- Pulumi, CDK, of Crossplane — andere IaC-tools, andere patronen
+- Helm chart-configuratie (gebruik in plaats daarvan de Kubernetes skill)
+- Configuratie op applicatieniveau (Kubernetes ConfigMaps, app-omgevingsvariabelen)
+- Eenmalige CLI-operaties die niet herhaald worden
+
+## Instructies
+
+### Module-structuur
+Elk Terraform-project moet deze structuur volgen:
+```
+infrastructure/
+├── modules/
+│   ├── networking/
+│   │   ├── main.tf
+│   │   ├── variables.tf
+│   │   ├── outputs.tf
+│   │   └── versions.tf
+│   └── compute/
+│       ├── main.tf
+│       ├── variables.tf
+│       └── outputs.tf
+├── environments/
+│   ├── production/
+│   │   ├── main.tf          ← roept modules aan
+│   │   ├── variables.tf
+│   │   ├── terraform.tfvars
+│   │   └── backend.tf
+│   └── staging/
+│       └── ...
+└── versions.tf              ← root provider-versies
+```
+
+### State-beheer — altijd remote
+```hcl
+# backend.tf
+terraform {
+  backend "s3" {
+    bucket         = "company-terraform-state"
+    key            = "production/networking/terraform.tfstate"
+    region         = "eu-west-1"
+    encrypt        = true
+    dynamodb_table = "terraform-state-lock"
+  }
+}
+```
+- Gebruik nooit lokale state voor gedeelde zaken
+- Schakel encryptie en state-locking in (DynamoDB voor S3 backend)
+- Aparte state-bestanden per omgeving en per module (niet één grote state)
+
+### Variabelen en outputs discipline
+```hcl
+# variables.tf — altijd description en type opnemen
+variable "environment" {
+  description = "Deployment environment (production, staging, development)"
+  type        = string
+  validation {
+    condition     = contains(["production", "staging", "development"], var.environment)
+    error_message = "Environment must be production, staging, or development."
+  }
+}
+
+# outputs.tf — alles outputten wat een gebruikende module nodig kan hebben
+output "vpc_id" {
+  description = "The ID of the VPC"
+  value       = aws_vpc.main.id
+}
+```
+
+### Secrets — nooit in state of code
+- Zet nooit secrets in `terraform.tfvars` of hardcode ze in `.tf`-bestanden
+- Gebruik `data "aws_secretsmanager_secret_version"` of `data "google_secret_manager_secret_version"` om secrets te lezen bij apply
+- Gevoelige outputs: markeer met `sensitive = true` om te onderdrukken in plan-output
+- `.gitignore` moet bevatten: `*.tfvars`, `*.tfstate`, `*.tfstate.backup`, `.terraform/`
+
+### Naamconventies voor resources
+```hcl
+# Consistente naamgeving: {project}-{environment}-{resource}-{suffix}
+resource "aws_vpc" "main" {
+  cidr_block = var.vpc_cidr
+  tags = {
+    Name        = "${var.project}-${var.environment}-vpc"
+    Environment = var.environment
+    ManagedBy   = "terraform"
+  }
+}
+```
+Tag elke resource altijd met `Environment` en `ManagedBy = "terraform"`.
+
+### Plan voor apply — altijd
+- CI/CD-pipeline: `terraform plan -out=tfplan` bij PR, `terraform apply tfplan` bij merge
+- Voer nooit `terraform apply` uit zonder een opgeslagen plan in productie
+- Gebruik `-target` spaarzaam — het creëert drift tussen werkelijke state en plan
+
+### Veelvoorkomende valkuilen
+- `terraform destroy` zonder `-target` vernietigt alles — bevestig altijd de reikwijdte
+- Een resource-attribuut wijzigen dat vervanging forceert (bijv. VPC CIDR) verwijdert en herschept — controleer plan zorgvuldig
+- Provider versie-pinning is verplicht: gebruik `~> 5.0` niet `>= 5.0`
+- `count` vs `for_each`: gebruik `for_each` met maps — `count` veroorzaakt index-drift wanneer items worden verwijderd
+
+## Voorbeeld
+
+**Gebruiker:** Maak een Terraform-module voor een private RDS PostgreSQL-instantie op AWS met Multi-AZ, versleutelde opslag en een toegewijd security group.
+
+**Verwachte outputstructuur:**
+- `modules/rds/main.tf` — `aws_db_instance`, `aws_db_subnet_group`, `aws_security_group`
+- `modules/rds/variables.tf` — instantieklasse, engine-versie, db-naam, VPC/subnet-ID's, ingress CIDR
+- `modules/rds/outputs.tf` — endpoint, port, security group ID
+- Security group: staat PostgreSQL (5432) alleen toe vanuit app security group, geen publieke toegang
+- `storage_encrypted = true`, `multi_az = true`, `deletion_protection = true` voor productie
+- Wachtwoord via `aws_secretsmanager_secret`-referentie, nooit hardcoded
+
+---
+
+> **Werk met ons:** Claudient wordt ondersteund door [Uitbreiden](https://uitbreiden.com/) — we bouwen AI-producten en B2B-oplossingen met ontwikkelaarsgemeenschappen. Cloud-infrastructuur of IaC-pipelines bouwen? [uitbreiden.com](https://uitbreiden.com/)

package/skills/devops-infra/terraform.md

@@ -0,0 +1,128 @@
+# Terraform Skill
+
+## When to activate
+- Writing Terraform modules for AWS, GCP, or Azure infrastructure
+- Defining VPCs, subnets, security groups, and networking resources
+- Provisioning compute resources (EC2, GKE, AKS, ECS, Lambda)
+- Managing database infrastructure (RDS, Cloud SQL, Aurora)
+- Setting up IAM roles, policies, and service accounts
+- Writing remote state configuration (S3 backend, GCS, Terraform Cloud)
+- Refactoring existing Terraform to use modules
+- Writing CI/CD pipelines for `terraform plan` and `terraform apply`
+- Importing existing infrastructure into Terraform state
+
+## When NOT to use
+- Pulumi, CDK, or Crossplane — different IaC tools, different patterns
+- Helm chart configuration (use the Kubernetes skill instead)
+- Application-level config (Kubernetes ConfigMaps, app env vars)
+- One-off CLI operations that won't be repeated
+
+## Instructions
+
+### Module structure
+Every Terraform project must follow this structure:
+```
+infrastructure/
+├── modules/
+│   ├── networking/
+│   │   ├── main.tf
+│   │   ├── variables.tf
+│   │   ├── outputs.tf
+│   │   └── versions.tf
+│   └── compute/
+│       ├── main.tf
+│       ├── variables.tf
+│       └── outputs.tf
+├── environments/
+│   ├── production/
+│   │   ├── main.tf          ← calls modules
+│   │   ├── variables.tf
+│   │   ├── terraform.tfvars
+│   │   └── backend.tf
+│   └── staging/
+│       └── ...
+└── versions.tf              ← root provider versions
+```
+
+### State management — always remote
+```hcl
+# backend.tf
+terraform {
+  backend "s3" {
+    bucket         = "company-terraform-state"
+    key            = "production/networking/terraform.tfstate"
+    region         = "eu-west-1"
+    encrypt        = true
+    dynamodb_table = "terraform-state-lock"
+  }
+}
+```
+- Never use local state for anything shared
+- Enable encryption and state locking (DynamoDB for S3 backend)
+- Separate state files per environment and per module (not one giant state)
+
+### Variable and output discipline
+```hcl
+# variables.tf — always include description and type
+variable "environment" {
+  description = "Deployment environment (production, staging, development)"
+  type        = string
+  validation {
+    condition     = contains(["production", "staging", "development"], var.environment)
+    error_message = "Environment must be production, staging, or development."
+  }
+}
+
+# outputs.tf — output everything a consuming module might need
+output "vpc_id" {
+  description = "The ID of the VPC"
+  value       = aws_vpc.main.id
+}
+```
+
+### Secrets — never in state or code
+- Never put secrets in `terraform.tfvars` or hardcode them in `.tf` files
+- Use `data "aws_secretsmanager_secret_version"` or `data "google_secret_manager_secret_version"` to read secrets at apply time
+- Sensitive outputs: mark with `sensitive = true` to suppress in plan output
+- `.gitignore` must include: `*.tfvars`, `*.tfstate`, `*.tfstate.backup`, `.terraform/`
+
+### Resource naming conventions
+```hcl
+# Consistent naming: {project}-{environment}-{resource}-{suffix}
+resource "aws_vpc" "main" {
+  cidr_block = var.vpc_cidr
+  tags = {
+    Name        = "${var.project}-${var.environment}-vpc"
+    Environment = var.environment
+    ManagedBy   = "terraform"
+  }
+}
+```
+Always tag every resource with `Environment` and `ManagedBy = "terraform"`.
+
+### Plan before apply — always
+- CI/CD pipeline: `terraform plan -out=tfplan` on PR, `terraform apply tfplan` on merge
+- Never run `terraform apply` without a saved plan in production
+- Use `-target` sparingly — it creates drift between real state and plan
+
+### Common pitfalls
+- `terraform destroy` with no `-target` destroys everything — always confirm scope
+- Changing a resource attribute that forces replacement (e.g., VPC CIDR) deletes and recreates — check plan carefully
+- Provider version pinning is mandatory: use `~> 5.0` not `>= 5.0`
+- `count` vs `for_each`: use `for_each` with maps — `count` causes index drift when items are removed
+
+## Example
+
+**User:** Create a Terraform module for a private RDS PostgreSQL instance on AWS with Multi-AZ, encrypted storage, and a dedicated security group.
+
+**Expected output structure:**
+- `modules/rds/main.tf` — `aws_db_instance`, `aws_db_subnet_group`, `aws_security_group`
+- `modules/rds/variables.tf` — instance class, engine version, db name, VPC/subnet IDs, ingress CIDR
+- `modules/rds/outputs.tf` — endpoint, port, security group ID
+- Security group: allows PostgreSQL (5432) only from app security group, no public access
+- `storage_encrypted = true`, `multi_az = true`, `deletion_protection = true` for production
+- Password via `aws_secretsmanager_secret` reference, never hardcoded
+
+---
+
+> **Work with us:** Claudient is backed by [Uitbreiden](https://uitbreiden.com/) — we build AI products and B2B solutions with developer communities. Building cloud infrastructure or IaC pipelines? [uitbreiden.com](https://uitbreiden.com/)