Ingress, Egress, LoadBalancers et TLS

# Vérifier le Service
kubectl get svc mon-application -n production
 
# Vérifier l'Ingress et son adresse IP
kubectl get ingress mon-application-public -n production
 
# Tester l'accès (remplacer par votre domaine)
curl -I http://www.votre-domaine.com

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: mon-application-secure-backend
  namespace: production
  annotations:
    # Active la communication HTTPS entre l'Ingress et le backend
    ingress.kubernetes.io/secure-backends: "true"
    # Optionnel : désactiver la vérification du certificat backend (non recommandé en prod)
    # ingress.kubernetes.io/secure-verify-ca-secret: "false"
spec:
  ingressClassName: public
  rules:
  - host: secure-backend.votre-domaine.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: mon-application
            port:
              number: 443  # Le service écoute en HTTPS

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: mon-application-tls
  namespace: production
  annotations:
    # Force HTTPS (redirection 301)
    ingress.kubernetes.io/ssl-redirect: "true"
    # Cert-Manager générera automatiquement le certificat (si le cluster issuer est configuré)
    cert-manager.io/cluster-issuer: letsencrypt-prod
spec:
  ingressClassName: public
  tls:
  - hosts:
    - api.votre-domaine.com
    secretName: api-votre-domaine-tls  # Cert-Manager créera ce Secret automatiquement
  rules:
  - host: api.votre-domaine.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: mon-application
            port:
              number: 80  # Backend en HTTP, TLS terminé au niveau Ingress

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: mon-application-private
  namespace: production
  annotations:
    ingress.kubernetes.io/whitelist-source-range: "10.0.0.0/8,172.16.0.0/12"  # Restriction IP
spec:
  ingressClassName: private  # Exposition sur la VIP privée uniquement
  rules:
  - host: internal-api.internal.{XXXX}.sdv.fr
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: mon-application-backend
            port:
              number: 8080

apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt-prod
spec:
  acme:
    # URL du serveur Let's Encrypt (production)
    server: https://acme-v02.api.letsencrypt.org/directory
    email: admin@votre-domaine.com
    privateKeySecretRef:
      name: letsencrypt-prod-account-key
    solvers:
    # Challenge HTTP-01 via Ingress
    - http01:
        ingress:
          class: public

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: mon-app-auto-tls
  namespace: production
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-prod
spec:
  ingressClassName: public
  tls:
  - hosts:
    - www.votre-domaine.com
    - api.votre-domaine.com
    secretName: votre-domaine-tls  # Cert-Manager créera automatiquement ce Secret
  rules:
  - host: www.votre-domaine.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: frontend
            port:
              number: 80
  - host: api.votre-domaine.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: backend-api
            port:
              number: 8080

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: mon-app-acme-tls
  annotations:
    ingress.kubernetes.io/cert-signer: acme
spec:
  ingressClassName: public
  tls:
    - hosts:
        - www.votre-domaine.com
        - api.votre-domaine.com
      secretName: votre-domaine-tls  # HAProxy créera automatiquement ce Secret
  rules:
  - host: www.votre-domaine.com
    http:
      paths:
      - path: /
        pathType: ImplementationSpecific
        backend:
          service:
            name: frontend
            port:
              number: 80
  - host: api.votre-domaine.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: backend-api
            port:
              number: 8080

# Vérifier l'état du certificat géré par Cert-Manager
kubectl get certificate -n production
kubectl describe certificate votre-domaine-tls -n production
 
# Vérifier le Secret TLS créé
kubectl get secret votre-domaine-tls -n production
 
# Tester le certificat via OpenSSL
openssl s_client -connect www.votre-domaine.com:443 -servername www.votre-domaine.com
 
# Vérifier l'expiration du certificat
echo | openssl s_client -connect www.votre-domaine.com:443 -servername www.votre-domaine.com 2>/dev/null | openssl x509 -noout -dates

# Forcer le renouvellement d'un certificat
kubectl delete certificaterequest -n production -l cert-manager.io/certificate-name=votre-domaine-tls
 
# Ou supprimer le Secret pour forcer une régénération
kubectl delete secret votre-domaine-tls -n production

apiVersion: v1
kind: Service
metadata:
  name: postgres-external
  namespace: production
  labels:
    app: postgres
spec:
  type: LoadBalancer
  # Adresse IP fournie par SdV dans le pool MetalLB
  loadBalancerIP: "203.0.113.10"
  selector:
    app: postgres
    tier: database
  ports:
  - name: postgres
    protocol: TCP
    port: 5432
    targetPort: 5432

# Vérifier l'allocation de l'IP externe
kubectl get svc postgres-external -n production
# Attendez que EXTERNAL-IP affiche l'IP configurée
 
# Tester la connexion depuis l'extérieur
psql -h 203.0.113.10 -U username -d database

apiVersion: v1
kind: Service
metadata:
  name: gameserver-udp
  namespace: gaming
spec:
  type: LoadBalancer
  loadBalancerIP: "203.0.113.20"
  selector:
    app: gameserver
  ports:
  - name: game-udp
    protocol: UDP
    port: 7777
    targetPort: 7777
  - name: game-query
    protocol: UDP
    port: 27015
    targetPort: 27015

apiVersion: v1
kind: Service
metadata:
  name: api-external
  namespace: production
spec:
  type: LoadBalancer
  loadBalancerIP: "203.0.113.40"
  externalTrafficPolicy: Local  # L'IP source du client est préservée
  selector:
    app: api-gateway
  ports:
  - port: 8080
    protocol: TCP

apiVersion: v1
kind: Service
metadata:
  name: postgres-secure
  namespace: production
spec:
  type: LoadBalancer
  loadBalancerIP: "10.0.1.50"  # IP privée
  externalTrafficPolicy: Local
  # Restriction par IP source
  loadBalancerSourceRanges:
  - "10.0.0.0/8"      # Réseau interne
  - "172.16.0.0/12"   # Réseau VPN
  selector:
    app: postgres
  ports:
  - port: 5432
    protocol: TCP

# Lancer un pod temporaire
kubectl run -it --rm debug \
  --image=curlimages/curl \
  --restart=Never \
  -- curl -s 'https://api.ipify.org?format=json'

{
  "ip": "213.225.160.2"
}

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all
  namespace: production
spec:
  podSelector: {}  # Sélectionne tous les Pods du namespace
  policyTypes:
  - Ingress
  - Egress
  # Pas de règles ingress/egress = tout est bloqué

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-from-ingress
  namespace: production
spec:
  podSelector:
    matchLabels:
      app: frontend
  policyTypes:
  - Ingress
  ingress:
  - from:
    # Autoriser le trafic depuis les Pods de l'Ingress Controller
    - namespaceSelector:
        matchLabels:
          name: ingress-controller
      podSelector:
        matchLabels:
          app: haproxy-ingress
    ports:
    - protocol: TCP
      port: 8080

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: postgres-allow-backend
  namespace: databases
spec:
  podSelector:
    matchLabels:
      app: postgres
  policyTypes:
  - Ingress
  ingress:
  - from:
    # Autoriser uniquement depuis le namespace "production"
    - namespaceSelector:
        matchLabels:
          name: production
      podSelector:
        matchLabels:
          app: backend-api
    ports:
    - protocol: TCP
      port: 5432

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: backend-egress
  namespace: production
spec:
  podSelector:
    matchLabels:
      app: backend-api
  policyTypes:
  - Egress
  egress:
  # Autoriser DNS (nécessaire pour la résolution de noms)
  - to:
    - namespaceSelector:
        matchLabels:
          name: kube-system
      podSelector:
        matchLabels:
          k8s-app: kube-dns
    ports:
    - protocol: UDP
      port: 53
  # Autoriser PostgreSQL
  - to:
    - namespaceSelector:
        matchLabels:
          name: databases
      podSelector:
        matchLabels:
          app: postgres
    ports:
    - protocol: TCP
      port: 5432
  # Autoriser accès HTTPS externe (API tierces)
  - to:
    - ipBlock:
        cidr: 0.0.0.0/0
        except:
        - 10.0.0.0/8
        - 172.16.0.0/12
        - 192.168.0.0/16
    ports:
    - protocol: TCP
      port: 443

# Lister les NetworkPolicies d'un namespace
kubectl get networkpolicy -n production
 
# Afficher les détails d'une NetworkPolicy
kubectl describe networkpolicy allow-from-ingress -n production
 
# Tester la connectivité depuis un Pod
kubectl exec -it mon-pod -n production -- curl http://service-cible:8080
 
# Tester la résolution DNS
kubectl exec -it mon-pod -n production -- nslookup kubernetes.default
 
# Vérifier les règles appliquées sur un nœud (si Calico)
kubectl exec -n kube-system calico-node-xxxxx -- iptables-save | grep production

# 1. Vérifier la résolution DNS
dig www.votre-domaine.com
nslookup www.votre-domaine.com
 
# 2. Vérifier l'Ingress
kubectl get ingress -n production
kubectl describe ingress mon-ingress -n production
 
# 3. Vérifier le Service
kubectl get svc mon-application -n production
 
# 4. Vérifier les Pods backend
kubectl get pods -n production -l app=mon-application
 
# 5. Vérifier les logs de l'Ingress Controller
kubectl logs -n ingress-controller -l app=haproxy-ingress --tail=100
 
# 6. Tester depuis un Pod dans le cluster
kubectl run -it --rm debug --image=curlimages/curl --restart=Never -- \
  curl -v -H "Host: www.votre-domaine.com" http://mon-application.production.svc.cluster.local

# Vérifier que les `Pods` backend sont en Running et Ready
kubectl get pods -n production -l app=mon-application -o wide
 
# Vérifier les logs applicatifs
kubectl logs -n production mon-application-xxxxx --tail=50
 
# Vérifier que le port targetPort correspond bien au port d'écoute de l'application
kubectl get svc mon-application -n production -o yaml | grep -A 5 ports
 
# Tester la connectivité directe au Pod
kubectl exec -it debug-pod -n production -- curl http://<POD_IP>:8080

# Vérifier le Secret TLS
kubectl get secret mon-certificat-tls -n production
 
# Vérifier le contenu du certificat
kubectl get secret mon-certificat-tls -n production -o jsonpath='{.data.tls\.crt}' | base64 -d | openssl x509 -text -noout
 
# Vérifier l'état du Certificate (si Cert-Manager)
kubectl get certificate -n production
kubectl describe certificate mon-certificat -n production
 
# Vérifier les logs de Cert-Manager
kubectl logs -n cert-manager -l app=cert-manager --tail=100
 
# Forcer un renouvellement
kubectl delete certificaterequest -n production -l cert-manager.io/certificate-name=mon-certificat

# Vérifier les événements du Service
kubectl describe svc mon-service-lb -n production
 
# Contacter les équipes SdV si le pool IP n'est pas configuré

# Vérifier que le Service a bien une EXTERNAL-IP
kubectl get svc mon-service-lb -n production
 
# Vérifier les endpoints du Service
kubectl get endpoints mon-service-lb -n production
 
# Vérifier que les `Pods` backend sont en Running
kubectl get pods -n production -l app=mon-app
 
# Tester la connectivité réseau depuis l'extérieur
telnet <EXTERNAL_IP> <PORT>
nc -zv <EXTERNAL_IP> <PORT>
 
# Vérifier les règles firewall et loadBalancerSourceRanges
kubectl get svc mon-service-lb -n production -o yaml | grep -A 10 loadBalancerSourceRanges

# Lister les NetworkPolicies appliquées au Pod source
kubectl get networkpolicy -n production
 
# Vérifier les sélecteurs de la NetworkPolicy
kubectl describe networkpolicy ma-policy -n production
 
# Vérifier les labels du Pod
kubectl get pod mon-pod -n production --show-labels
 
# Tester la connectivité avec netcat/curl depuis le Pod
kubectl exec -it mon-pod -n production -- curl -v http://service-cible:8080
 
# Désactiver temporairement une NetworkPolicy pour tester
kubectl delete networkpolicy ma-policy -n production
# (N'oubliez pas de la recréer ensuite !)

# Vérifier le Service kube-dns
kubectl get svc -n kube-system kube-dns
 
# Vérifier les `Pods` CoreDNS
kubectl get pods -n kube-system -l k8s-app=kube-dns
 
# Tester la résolution DNS depuis un Pod
kubectl run -it --rm debug --image=busybox --restart=Never -- nslookup kubernetes.default
 
# Vérifier la configuration CoreDNS
kubectl get configmap coredns -n kube-system -o yaml
 
# Logs de CoreDNS
kubectl logs -n kube-system -l k8s-app=kube-dns --tail=50

# Déployer un `Pod` de debug avec outils réseau
kubectl run netshoot --rm -it --image=nicolaka/netshoot -- /bin/bash
 
# Une fois dans le Pod, vous avez accès à :
# - curl, wget, http
# - ping, traceroute, mtr
# - nslookup, dig, host
# - netcat (nc)
# - tcpdump
# - iperf3
 
# Exemple : analyser le trafic réseau
tcpdump -i any -n port 8080
 
# Exemple : tester la bande passante
iperf3 -s  # Sur le serveur
iperf3 -c <SERVER_IP>  # Sur le client

# Afficher tous les Services avec leurs EXTERNAL-IP
kubectl get svc --all-namespaces -o wide
 
# Afficher tous les Ingress avec leurs hôtes
kubectl get ingress --all-namespaces
 
# Afficher les Endpoints pour vérifier la connectivité Service→Pods
kubectl get endpoints -n production
 
# Suivre les événements en temps réel
kubectl get events -n production --watch
 
# Vérifier les quotas réseau (si configurés)
kubectl describe resourcequota -n production
 
# Afficher la configuration réseau d'un Pod
kubectl get pod mon-pod -n production -o jsonpath='{.status.podIP}'
kubectl get pod mon-pod -n production -o jsonpath='{.spec.containers[0].ports}'