This is an old revision of the document!

Uso do ''--dry-run=client'' para Gerar Manifests Kubernetes

O comando `kubectl` com a opção –dry-run=client é extremamente útil para gerar esqueletos de manifestos YAML sem aplicar as alterações no cluster. Esta técnica é ideal para criar templates iniciais que podem ser posteriormente customizados.

Comandos ''dry-run'' Úteis para o Cenário phpIPAM

1. ConfigMap

ConfigMap com múltiplos valores literais:

kubectl create configmap phpipam-config \
  --from-literal=TZ="America/Sao_Paulo" \
  --from-literal=SCAN_INTERVAL="1h" \
  --from-literal=IPAM_DATABASE_HOST="phpipam-db" \
  --from-literal=IPAM_DISABLE_INSTALLER="0" \
  -n phpipam-system \
  --dry-run=client \
  -o yaml > configmap.yaml

ConfigMap a partir de arquivo:

kubectl create configmap phpipam-config \
  --from-file=./configs/ \
  -n phpipam-system \
  --dry-run=client \
  -o yaml > configmap-from-files.yaml

2. PersistentVolumeClaim (PVC)

kubectl create pvc phpipam-db-pvc \
  --namespace=phpipam-system \
  --storage-class=default-storageclass \
  --access-mode=ReadWriteOnce \
  --volume-mode=Filesystem \
  --requests=storage=15Gi \
  --dry-run=client \
  -o yaml > pvc.yaml

3. Deployment com Mais Opções

Deployment com réplicas definidas:

kubectl create deployment phpipam-web \
  --image=phpipam/phpipam-www:v1.7.4 \
  --namespace=phpipam-system \
  --replicas=1 \
  --port=80 \
  --dry-run=client \
  -o yaml > deployment-web.yaml

Deployment com variáveis de ambiente:

kubectl create deployment phpipam-web \
  --image=phpipam/phpipam-www:v1.7.4 \
  --namespace=phpipam-system \
  --env="TZ=America/Sao_Paulo" \
  --env="IPAM_DATABASE_HOST=phpipam-db" \
  --dry-run=client \
  -o yaml > deployment-web-with-env.yaml

4. Service com Tipo Específico

Service ClusterIP (padrão):

kubectl create service clusterip phpipam-web \
  --tcp=80:80 \
  --namespace=phpipam-system \
  --dry-run=client \
  -o yaml > service-web.yaml

Service LoadBalancer (se necessário acesso direto):

kubectl create service loadbalancer phpipam-web \
  --tcp=80:80 \
  --namespace=phpipam-system \
  --dry-run=client \
  -o yaml > service-web-lb.yaml

Service NodePort:

kubectl create service nodeport phpipam-web \
  --tcp=80:80 \
  --node-port=30080 \
  --namespace=phpipam-system \
  --dry-run=client \
  -o yaml > service-web-nodeport.yaml

5. Service Headless para StatefulSet/Deployment de Banco

kubectl create service clusterip phpipam-db \
  --tcp=3306:3306 \
  --clusterip="None" \
  --namespace=phpipam-system \
  --dry-run=client \
  -o yaml > service-db-headless.yaml

6. Resource Quota (para limites de namespace)

kubectl create quota phpipam-quota \
  --namespace=phpipam-system \
  --hard=cpu=2,memory=4Gi,requests.cpu=1,requests.memory=2Gi,pods=10 \
  --dry-run=client \
  -o yaml > resource-quota.yaml

7. LimitRange (para limites padrão em containers)

kubectl create limitrange phpipam-limits \
  --namespace=phpipam-system \
  --max-cpu=2 \
  --max-memory=4Gi \
  --min-cpu=100m \
  --min-memory=128Mi \
  --default-cpu=500m \
  --default-memory=1Gi \
  --dry-run=client \
  -o yaml > limitrange.yaml

8. NetworkPolicy (para segurança de rede)

kubectl create networkpolicy phpipam-network-policy \
  --namespace=phpipam-system \
  --pod-selector=app=phpipam-web \
  --ingress='[{"from":[{"podSelector":{"matchLabels":{"app":"phpipam-web"}}}],"ports":[{"protocol":"TCP","port":80}]}]' \
  --dry-run=client \
  -o yaml > networkpolicy.yaml

9. ServiceAccount e RoleBinding

ServiceAccount:

kubectl create serviceaccount phpipam-sa \
  --namespace=phpipam-system \
  --dry-run=client \
  -o yaml > serviceaccount.yaml

Role:

kubectl create role phpipam-role \
  --namespace=phpipam-system \
  --verb=get,list,watch \
  --resource=pods,services \
  --dry-run=client \
  -o yaml > role.yaml

RoleBinding:

kubectl create rolebinding phpipam-rolebinding \
  --namespace=phpipam-system \
  --role=phpipam-role \
  --serviceaccount=phpipam-system:phpipam-sa \
  --dry-run=client \
  -o yaml > rolebinding.yaml

10. Secret TLS (alternativa ao generic)

# Secret TLS (precisa dos arquivos .crt e .key)
kubectl create secret tls tls-secret-phpipam \
  --cert=path/to/cert.crt \
  --key=path/to/cert.key \
  --namespace=phpipam-system \
  --dry-run=client \
  -o yaml > tls-secret.yaml

11. StatefulSet (alternativa para banco de dados)

kubectl create statefulset phpipam-db \
  --image=mariadb:11.8 \
  --namespace=phpipam-system \
  --service=phpipam-db \
  --dry-run=client \
  -o yaml > statefulset-db.yaml

12. Pod (para testes rápidos)

kubectl run phpipam-test \
  --image=phpipam/phpipam-www:v1.7.4 \
  --namespace=phpipam-system \
  --restart=Never \
  --dry-run=client \
  -o yaml > test-pod.yaml

13. Job/CronJob (para tarefas agendadas)

CronJob para backup:

kubectl create cronjob phpipam-backup \
  --image=mariadb:11.8 \
  --namespace=phpipam-system \
  --schedule="0 2 * * *" \
  --dry-run=client \
  -o yaml > cronjob-backup.yaml

14. HorizontalPodAutoscaler

kubectl autoscale deployment phpipam-web \
  --namespace=phpipam-system \
  --min=1 \
  --max=3 \
  --cpu-percent=80 \
  --dry-run=client \
  -o yaml > hpa.yaml

15. PodDisruptionBudget

kubectl create poddisruptionbudget phpipam-pdb \
  --namespace=phpipam-system \
  --selector=app=phpipam-web \
  --max-unavailable=1 \
  --dry-run=client \
  -o yaml > pdb.yaml

Script Completo para Gerar Todos os Manifests do phpIPAM

#!/bin/bash
# generate-phpipam-manifests.sh
 
echo "=== Gerando todos os manifests para phpIPAM ==="
 
# Namespace
kubectl create namespace phpipam-system --dry-run=client -o yaml > namespace.yaml
 
# ConfigMap
kubectl create configmap phpipam-config \
  --from-literal=TZ="America/Sao_Paulo" \
  --from-literal=SCAN_INTERVAL="1h" \
  --from-literal=IPAM_DATABASE_HOST="phpipam-db" \
  --from-literal=IPAM_DATABASE_WEBHOST="%" \
  --from-literal=IPAM_TRUST_X_FORWARDED="true" \
  --from-literal=IPAM_DISABLE_INSTALLER="0" \
  -n phpipam-system \
  --dry-run=client -o yaml > configmap.yaml
 
# Secret
kubectl create secret generic phpipam-secrets \
  --from-literal=DB_ROOT_PASSWORD="CHANGE_ME" \
  --from-literal=DB_PASSWORD="CHANGE_ME" \
  -n phpipam-system \
  --dry-run=client -o yaml > secrets.yaml
 
# PVC
kubectl create pvc phpipam-db-pvc \
  --namespace=phpipam-system \
  --storage-class=default-storageclass \
  --access-mode=ReadWriteOnce \
  --requests=storage=15Gi \
  --dry-run=client -o yaml > pvc.yaml
 
# Deployment MariaDB
kubectl create deployment phpipam-db \
  --image=mariadb:11.8 \
  --namespace=phpipam-system \
  --dry-run=client -o yaml > deployment-db.yaml
 
# Service MariaDB
kubectl create service clusterip phpipam-db \
  --tcp=3306:3306 \
  --namespace=phpipam-system \
  --dry-run=client -o yaml > service-db.yaml
 
# Deployment phpIPAM Web
kubectl create deployment phpipam-web \
  --image=phpipam/phpipam-www:v1.7.4 \
  --namespace=phpipam-system \
  --dry-run=client -o yaml > deployment-web.yaml
 
# Service phpIPAM Web
kubectl create service clusterip phpipam-web \
  --tcp=80:80 \
  --namespace=phpipam-system \
  --dry-run=client -o yaml > service-web.yaml
 
# Deployment phpIPAM Cron
kubectl create deployment phpipam-cron \
  --image=phpipam/phpipam-cron:latest \
  --namespace=phpipam-system \
  --dry-run=client -o yaml > deployment-cron.yaml
 
# Ingress
kubectl create ingress phpipam-ingress \
  --class=nginx \
  --rule="ipam-hml.sefaz.rn.gov.br/*=phpipam-web:80" \
  --namespace=phpipam-system \
  --dry-run=client -o yaml > ingress.yaml
 
echo "✅ Todos os manifests foram gerados!"
echo ""
echo "=== PRÓXIMOS PASSOS ==="
echo "1. Edite os arquivos gerados para adicionar:"
echo "   - Variáveis de ambiente nos deployments"
echo "   - SecurityContext com capabilities"
echo "   - Resources requests/limits"
echo "   - Volumes e volumeMounts"
echo "   - Probes (liveness/readiness)"
echo ""
echo "2. Gere senhas seguras e atualize secrets.yaml"
echo "3. Aplique os manifests: kubectl apply -f ."

Dicas Extras de Uso do dry-run

Visualizar diferenças antes de aplicar:

# Ver o que seria criado
kubectl create deployment test --image=nginx --dry-run=client -o yaml
 
# Ver diferenças entre o que existe e o que seria criado
kubectl diff -f deployment.yaml

Validar manifests gerados:

# Validar sintaxe YAML
kubectl create deployment test --image=nginx --dry-run=client -o yaml | yamllint -
 
# Validar no servidor (validação mais completa)
kubectl create deployment test --image=nginx --dry-run=server

Gerar com diferentes formatos:

# JSON em vez de YAML
kubectl create deployment test --image=nginx --dry-run=client -o json
 
# Wide output
kubectl create deployment test --image=nginx --dry-run=client -o wide

Limitações do dry-run

Não gera tudo automaticamente: Para configurações complexas (securityContext, volumes complexos, etc.), você precisa editar manualmente.
Não valida referências: Não verifica se Secrets, ConfigMaps ou Services referenciados existem.
Alguns recursos não suportam: Certos recursos avançados podem não ter suporte completo.

Para o phpIPAM Específico

Após gerar os manifests básicos com `dry-run`, você precisará editar manualmente para adicionar:

Capabilities de rede (`NET_ADMIN`, `NET_RAW`)
Variáveis de ambiente complexas (com `valueFrom`)
Volume mounts para persistência
Resources limits e requests
Probes (liveness, readiness)
Anotações no Ingress

Exemplo de edição pós-dry-run:

# Após gerar deployment-web.yaml com dry-run, adicione:
spec:
  template:
    spec:
      containers:
      - name: phpipam-web
        securityContext:
          capabilities:
            add: ["NET_ADMIN", "NET_RAW"]
        env:
        - name: IPAM_DATABASE_PASS
          valueFrom:
            secretKeyRef:
              name: phpipam-secrets
              key: DB_PASSWORD
        # ... outras variáveis

Base de Conhecimento

Table of Contents