Accéder à un service du tailnet depuis une sandbox

• Exposer un Service interne au cluster via l’opérateur Tailscale permet aux appareils du tailnet de s’y connecter. En revanche, les connexions sortantes d’un Pod vers un appareil du tailnet nécessitent la fonctionnalité de trafic sortant de cluster de Tailscale.
• Les règles de trafic sortant des Sandbox ne peuvent qu’autoriser du trafic, sur une référence qui refuse tout par défaut, et EgressRule(any=True) exclut les adresses internes au cluster. Une destination interne au cluster, comme un proxy Tailscale, n’est donc accessible que par une règle selector ou tenant.

​

Prérequis

• Un cluster CKS doté d’un exécuteur de sandbox managé dont le installStatus est READY. Voir Utiliser votre propre infrastructure de calcul.
• L’opérateur Kubernetes Tailscale installé sur ce cluster, avec le fichier de politique de votre tailnet configuré pour CKS. Voir Déployer l’opérateur Kubernetes Tailscale.
• Le nom MagicDNS de l’appareil du tailnet que vous souhaitez joindre, par exemple db-host.[TAILNET-NAME].ts.net, ainsi que le port sur lequel votre service écoute.
• Une politique de l’exécuteur qui autorise cette règle de trafic sortant par sélecteur. Un droit any ne couvre jamais les sélecteurs. Une politique dont le champ allowed_egress n’est pas vide doit donc comporter un droit selector de forme correspondante : il doit également définir namespace_labels, ses libellés doivent former un sous-ensemble de ceux que déclare la sandbox, et son filtre de port doit couvrir le port TCP 8080. Voir SelectorBlock.
• Le SDK Python cwsandbox configuré avec des identifiants d’authentification pour le placement CKS, ainsi qu’une image de sandbox dans laquelle curl et getent sont installés.
• Un accès kubectl permettant de créer ou de mettre à jour des Services dans le namespace default et de lister les Pods dans le namespace de l’opérateur.
• Une politique de tailnet qui autorise le proxy de trafic sortant à se connecter à l’appareil cible et au port de l’application.

​

Créer un Service de trafic sortant Tailscale

apiVersion: v1
kind: Service
metadata:
  name: internal-api
  namespace: default
  annotations:
    tailscale.com/tailnet-fqdn: "[TAILNET-FQDN]"
spec:
  type: ExternalName
  externalName: placeholder.tailscale.internal # Requis par Kubernetes, écrasé par l’opérateur

kubectl apply -f tailnet-egress.yaml

kubectl get pods -n tailscale \
  -l 'tailscale.com/parent-resource=internal-api,tailscale.com/parent-resource-ns=default'

NAME                     READY   STATUS    RESTARTS   AGE
ts-internal-api-k4x7p-0  1/1     Running   0          32s

​

Autoriser le trafic sortant de la sandbox vers le proxy

• pod_labels identifie le proxy par le Service qu’il expose, au moyen des libellés tailscale.com/parent-resource et tailscale.com/parent-resource-ns de l’opérateur. Incluez le libellé de namespace pour éviter que la règle ne corresponde aussi au proxy d’un Service homonyme situé dans un autre namespace.
• namespace_labels sélectionne le namespace tailscale. Sans ce paramètre, la règle s’applique uniquement au namespace de la sandbox et ne peut pas atteindre un proxy situé dans un autre namespace.

from cwsandbox import EgressRule, NetworkOptions, Sandbox, SelectorBlock

tailscale_egress = EgressRule(
    selector=SelectorBlock(
        pod_labels={
            "tailscale.com/parent-resource": "internal-api",
            "tailscale.com/parent-resource-ns": "default",
        },
        namespace_labels={"kubernetes.io/metadata.name": "tailscale"},
    ),
    ports=[8080],
)

with Sandbox.run(
    placement_mode="cks",
    runner_ids=["[RUNNER-ID]"],
    network=NetworkOptions(egress=[tailscale_egress]),
) as sandbox:
    result = sandbox.exec([
        "curl", "-sS", "--include", "--max-time", "15",
        "http://internal-api.default.svc.cluster.local:8080/health",
    ]).result()
    print(result.stdout)
    print(result.stderr)

​

Vérifier la connexion

from cwsandbox import EgressRule, NetworkOptions, Sandbox, SelectorBlock

tailscale_egress = EgressRule(
    selector=SelectorBlock(
        pod_labels={
            "tailscale.com/parent-resource": "internal-api",
            "tailscale.com/parent-resource-ns": "default",
        },
        namespace_labels={"kubernetes.io/metadata.name": "tailscale"},
    ),
    ports=[8080],
)

with Sandbox.run(
    placement_mode="cks",
    runner_ids=["[RUNNER-ID]"],
    network=NetworkOptions(egress=[tailscale_egress]),
) as sandbox:
    dns_result = sandbox.exec([
        "getent", "hosts", "internal-api.default.svc.cluster.local",
    ]).result()
    print(dns_result.stdout)
    print(dns_result.stderr)
    http_result = sandbox.exec([
        "curl", "-sv", "--max-time", "15", "-o", "/dev/null",
        "http://internal-api.default.svc.cluster.local:8080/health",
    ]).result()
    print(http_result.stderr)

​

Dépannage

​

Pages connexes

• Déployer l’Opérateur Kubernetes Tailscale : déployer et configurer l’opérateur sur CKS.
• Règles réseau : la référence complète de EgressRule et SelectorBlock.
• Référence des stratégies : les droits définis par la politique, dont une règle de trafic sortant déclarée ne doit pas sortir.
• Points de terminaison publics : attribuer une adresse publique à un service exécuté dans une sandbox.