Skip to content

Traefik Install

Traefik est installé avec le package helm officiel Traefik.

Le dashboard est géré dans un packet distinct ce qui permet de l'activer à la demande.

Création du Package Traefik

Créer un K8s / K8s Package avec:

  • Application: Traefik
  • Type: Helm Chart
  • Namespace required: Checked
  • Package Source: Helm repository
  • Helm repo. name: traefik-charts
  • Helm repo. URL: https://traefik.github.io/charts
  • Helm package name: traefik

Cliquez sur le bouton 'Refresh Package from source'.

Si tout est bon, Muppy va actualiser les les versions (Packages et App)

Création d'un Package Release Traefik

Dans Muppy, créer un Package Release en renseignant:

  • Cluster
  • Namespace: traefik-pack8s
  • Qualifier: Infrastructure
  • Package: Traefik v2.10.6 - 26.0.0 # ou supérieure
  • Helm Instance: traefik
  • Values:
    • ingressRoute.dashboard.enabled: false
    • providers.kubernetesCRD.allowCrossNamespace: true
      • required to allow Traefik Middleware to call TocToc endpoints
    • ports.web.redirectTo.port: websecure
    • ports.web.proxyProtocol.trustedIPs: ['{{ip publique du server}}']
    • ports.websecure.proxyProtocol.trustedIPs: ['{{ip publique du server}}']
    • service.type: LoadBalancer (c'est la valeur par défaut)

Cliquez sur [helm install] puis attendez environ 20 secondes.

Mise à jour du LoadBalancer (Clusters managés)

Récupération de l'external IP du LoadBalancer

Dans l'onglet Objects:

  1. Cliquez sur Update Info
  2. Ouvrez l'objet Kind: Service et vérifiez que ExternalIP est définie.
  3. Si ce n'est pas le cas, attendez et répetez à partir du 1.

Mise à jour du LoadBalancer (uniquement pour les clusters Self Hosted K0s ou microk8s)

Dans un cluster singlenode, si on crée un service Traefik de type LoadBalancer et:

  1. Si on patch le loadbalancer avec l'IP publique alors k8s expose les ports 80/http, 443/https et tous les NodePorts* sur l'IP publique.
    A noter: C'est la commande patch qui déclenche la publication des ports 80/http et 443/https sur l'IP publique.

  2. Si on patch le loadbalancer avec une IP privée sur un réseau mesh (type Tailscale, nebula,...) alors k8s expose les services 80/http et 443/https et tous les NodePorts sur l'ip Tailscale.
    Les services sont bien publiés sur le Tailnet (on peut y accéder normalement avec un browser sur une machine qui est dans le Tailnet). Mais RIEN n'est accessible publiquement.
    Pour exposer les ports 80/http et 443/https sur l'IP publique, il faut ajouter un LoadBalancer.

  3. Si on patch le loadbalancer avec un ip privée type Private Network (non Mesh), alors k8s expose les services http/80 et https/443 (et les NodePorts) sur l'IP privée (sur le réseau privée) mais rien n'est accessible publiquement et il faut un LoadBalancer avec un IP Public pour exposer le traffic.

Conclusion:

Le setup Muppy consiste à:

  • Publier (toujours) K8s sur une IP Privée (Mesh ou Private)
  • Utiliser un LoadBalancer Externe au Cluster (As a Service ou géré par Muppy) pour exposer les services publiquement
  • Filtrer les accès à 2 niveaux:
    • LoadBalancer Externe (Couche 4)
    • IngressRoutes (Couche 7)

Avec ce setup, on peut configurer les services pour les exposer publiquement ou uniquement sur le réseau privé. Par exemple, Les dashboards Traefik et K8s sont publiés dans un Tailnet mais les applis sont exposées publiquement.

Publier des services privés

Pour publier sur le réseau privé, il y a 2 options: 1. Tous les services du cluster sont privés. 2. Le cluster héberge des services privés et des services publiques

Option 1: Tous les services sont privés

Dans ce cas, le plus simple est de ne pas installer de load balancer externe et de publicer tous les services sur l'IP Privée.

Option 2: Le cluster héberge des services privés et des services publiques
  • définir un record DNS qui pointe sur l'IP Privée
  • restreindre l'accès à l'ingressRoute (en configurant l'ipWhitelisting pour n'autoriser que l'IP Publique du node)

Todo

  • Intégrer un LoadBalancer ultralight (eg. Envoy ?)
  • Utiliser une ingress dans le Tailnet

Configuration

Vérifiez que le LoadBalancer est bien en attente de son IP externe: 

➜  kubectl --kubeconfig=k0s-multinode-ctb.kubeconfig get -A svc
# or
➜  microk8s kubectl get -A svc
# or use muppy GUI in tab `Objects`of traefik K8s Package Release
NAMESPACE        NAME                   TYPE           CLUSTER-IP       EXTERNAL-IP       PORT(S)                      AGE
cert-manager     cert-manager           ClusterIP      10.103.233.62    <none>            9402/TCP                     14h
cert-manager     cert-manager-webhook   ClusterIP      10.103.156.229   <none>            443/TCP                      14h
default          kubernetes             ClusterIP      10.96.0.1        <none>            443/TCP                      15h
kube-system      kube-dns               ClusterIP      10.96.0.10       <none>            53/UDP,53/TCP,9153/TCP       15h
kube-system      metrics-server         ClusterIP      10.100.70.192    <none>            443/TCP                      15h
traefik-pack8s   traefik                LoadBalancer   10.97.226.173    <pending>         80:31432/TCP,443:30168/TCP   54m

Installation LoadBalancer externe

Nous allons utiliser Traefik comme loadbalancer externe.

Info

Si vous vous posez des questions sur les performances relatives de Traefik par rapport à d'autres LB. Nous vous invitons à lire https://www.loggly.com/blog/benchmarking-5-popular-load-balancers-nginx-haproxy-envoy-traefik-and-alb/

Traefik install as TCP LB

Nous installons un second Traefik dans le server, mais il sera utilisé uniquement en TCP LoadBalancer (L4).

Utilisez Network / Traefik Servers pour installer une instance de Traefik avec les paramètres suivants:

  • Host: Node Kubernetes
  • Domain: Sélectionnez n'importe quel domain, le champ est obligatoire mais le Domain ne sera pas utilisé
  • Traefik version: Sélectionnez la dernière version
  • Onget [Main Configuration]
    • Main Config Template: séectionnez la dernière version de Traefik2 - K8s TCP Router v? - Muppy
  • Onget [SSL & TLS]
    • Use Let's Encrypt: décochez (Traefik est utilisé pour load balancer du TCP pas du HTTP. La gestion des certificats est réalisée dans le cluster Kubernetes.
  • Cliquez sur [Save] puis sur [Edit]
  • Dans l'onglet [Applications], cliquez sur Add a ligne et entrez les valeurs suivantes:
    • Host Name: Entrez not-used, le hostname n'est pas utilisé en LB L4.
    • Onglet [Services], ajoutez 2 services (utilisez le bouton [Create] avec les valeurs suivantes:
    • Host=le node Kubernetes, Address=l'IP Privée, Network Port=80-tcp et Service=k8s-http
    • Host=le node Kubernetes, Address=l'IP Privée, Network Port=443-tcp et Service=k8s-https
    • Onglet [Config Template], dans App Config Template:
    • Sélectionnez la dernière version de Traefik2 K8s Loadbalancer (L4) App Config vx Yaml - Muppy
    • Cliquez sur le bouton [(Re)load]
    • Cliquez sur [Refresh] pour re-générer la configuration de l'application.
    • Cliquez sur [Save and Close] pour enregistrer et fermer l'application,
  • La configuration est terminée, cliquez sur [Save]

  • Cliquez sur le bouton [Reconfigure] et cochez :

    • Force Traefik Program (re)installation
    • Reset Certificate Store ​
    • Reconfigure Applications

La prochaine étape est de créer un K8s Object de type LoadBalancer qui permettra de choisir l'IP à utiliser pour exposer un Package Release.

Créer un K8s / K8s Object avec:

  • Cluster:
  • name: tcp-router@{{hostname}}
  • Kind: Service
  • namespace: n/a
  • Managed by: hand
  • type: LoadBalancer
  • External IP: ip publique
  • un flag "Managed manually" pour l'exclure de la synchro (avec la modif de la synchro)
  • (Plus tard) Un bouton qui permet de créer l'objet depuis le Traefik Server

A partir d'ici, il y a 2 possibilités selon que vous voulez ou pas que les ports HTTP et HTTPS soient publiquement accessibles:

1. Ports HTTP et HTTPS accessibles publiquement

Dans cette configuration, nous configurons Kubernetes pour qu'il utilise l' IP publique comme External IP. Kubernetes ou plutot Docker va utiliser iptable pour exposer les ports 80 et 443 sur l'interface publique via la table prerouting. La configuration Docker va donc prendre la main sur la configuration UFW de muppy mais uniquement pour les ports 80 et 443 gérés par Traefik.

Modifier le service pour affecter l'IP Publique du Node (ou de la gateway pour les clusters Multinodes). Par exemple pour 158.220.99.99

export MPY_K8S_NODE_PUBLIC_IP=158.220.99.99
kubectl patch svc -n traefik-pack8s traefik -p "{\"spec\": {\"externalIPs\": [\"$MPY_K8S_NODE_PUBLIC_IP\"]}}"

Vérifiez dans Muppy que le LoadBalancer a récupéré une externalIp.

2. Ports HTTP et HTTPS en accès restreint

Dans cette configuration, nous exposons Traefik sur l' IP Privée et nous installons un second LoadBalancer sur l'IP Publique qui balance le traffic TCP sur l'IP Privée. Cette configuration a 2 avantages: - UFW permet de filtrer les IP autorisés à accéder à l'interface publique - le LoadBalancer externe ajoute une filtrage des flux

Note

Cette configuration est la même que pour les clusters Multinodes. A ceci prêt que le LoadBalancer sera
installé sur un server distinct est que le traffic sera réparti sur plusieurs Nodes Workers Kubernetes.

Modifier le service pour affecter l'IP Privée du Node Par exemple pour 172.16.0.2

# Cas Private Network
export MPY_K8S_NODE_PRIVATE_IP=10.0.1.15

# Cas Tailscale
export MPY_K8S_NODE_PRIVATE_IP=$(sudo ip --json a | jq -r '.[] | select(.ifname == "tailscale0" ) | .addr_info[] | select(.family == "inet") | .local')

# Cas Nebula
export MPY_K8S_NODE_PRIVATE_IP=$(sudo ip --json a | jq -r '.[] | select(.ifname == "defined1") | .addr_info[] | select(.family == "inet") | .local')

kubectl patch svc -n traefik-pack8s traefik -p "{\"spec\": {\"externalIPs\": [\"$MPY_K8S_NODE_PRIVATE_IP\"]}}"

Configuration réseau du K8s Cluster

  • Ouvrez le formulaire du cluster dans Muppy ( K8s / K8s Clusters)
  • Dans l'onglet Network, mettez à jour:
    • Default LoadBalancer
    • DNS Domain
    • Hostname generator
    • Registration email

Controle exposition du host

Connectez vous en SSH sur un serveur qui n'est pas autorisé à accéder au host (dans Host / UFW) et vérifiez les ports ouverts:

nmap -p- {{node_public_ip}}
nmap -Pn {{node_public_ip}}