asanger.dev

Der Unterschied liegt darin, dass dein AKS-Cluster und der Kubelet (Node-Pool) unterschiedliche Managed Identities haben!

🔹 1. aks.identity[0].principal_id → Cluster-Managed Identity (System-Assigned oder User-Assigned)

Wenn du in Terraform data.azurerm_kubernetes_cluster.aks.identity[0].principal_id nutzt, bekommst du die Managed Identity des AKS-Clusters selbst.

Wann wird diese Identity verwendet?

  • Falls dein AKS-Cluster mit einer System-Assigned Identity oder einer User-Assigned Identity erstellt wurde.
  • Wird oft für API-Calls oder Berechtigungen auf Subscription-/Resource-Group-Ebene genutzt.
  • Diese ID wird genutzt, wenn du z. B. eine Azure Policy oder ein RBAC-Role Assignment für das AKS-Cluster machst.

💡 Beispiel:

data "azurerm_kubernetes_cluster" "aks" {
name = "aks-test"
resource_group_name = "aks-test"
}

output "aks_identity" {
value = data.azurerm_kubernetes_cluster.aks.identity[0].principal_id
}

Dieser Wert entspricht der „principalId“ des AKS-Clusters.


🔹 2. identityProfile.kubeletidentity.clientId → Kubelet-Managed Identity (Node Pool)

Die identityProfile.kubeletidentity.clientId, die du mit az aks show bekommst, gehört zur Kubelet-Managed Identity.

Wann wird diese Identity verwendet?

  • Diese Managed Identity wird von den AKS-Knoten (Worker Nodes) genutzt.
  • Sie wird verwendet, wenn die Nodes z. B. Azure Container Registry (ACR), Key Vault oder andere Azure-Ressourcen aufrufen.
  • Falls du Azure Files oder Azure Disks als Volumes mountest, nutzt der Kubelet-Daemon diese Identity.

💡 Beispiel:

aks show --resource-group aks-test --name aks-test --query "identityProfile.kubeletidentity.clientId" --output tsv

Dieser Wert entspricht der „clientId“ der Kubelet Identity.


🔹 Unterschied in der Praxis

Identity-TypTerraform (azurerm_kubernetes_cluster)CLI (az aks show)Verwendung
Cluster-Managed Identityaks.identity[0].principal_ididentity.principalIdWird für Azure-Ressourcen-Berechtigungen auf Cluster-Ebene genutzt
Kubelet-Managed Identity (Node Pool)Nicht direkt abrufbar mit TerraformidentityProfile.kubeletidentity.clientIdWird von Knoten für ACR, Key Vault, Azure Disks etc. genutzt

🔹 Wie bekomme ich die Kubelet-Identity mit Terraform?

Aktuell bietet Terraform keine direkte Möglichkeit, die kubeletidentity.clientId aus identityProfile abzurufen.
Ein Workaround wäre, das CLI-Kommando mit data "external" oder local-exec auszuführen:

data "external" "kubelet_identity" {
program = ["bash", "-c", "az aks show --resource-group aks-test --name aks-test --query 'identityProfile.kubeletidentity.clientId' --output tsv"]
}

output "kubelet_identity" {
value = data.external.kubelet_identity.result["client_id"]
}

📌 Fazit

  • aks.identity[0].principal_id ist die Managed Identity des Clusters.
  • identityProfile.kubeletidentity.clientId ist die Managed Identity der Worker Nodes (Kubelet).
  • Terraform kann die Kubelet Identity aktuell nicht direkt abrufen – nur über az aks show.

Möchtest du noch genauere Details zu deiner AKS-Konfiguration? 😊

4o

terraform state pull > backup.tfstate

Falls etwas schiefgeht, kannst du den State mit terraform state push wiederherstellen.

Prozess (Pid) auflisten der auf das device zugreift:

$ fuser -u /home/tom/directory
/home/thomas/directory:   2435828(thomas)

$ ps -p 2435828
PID TTY          TIME CMD
2435828 ?        00:00:01 nautilus

oder

$ lsof -l -w /home/thomas/directory
COMMAND      PID     USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
nautilus 2435828     1000   27r   DIR   0,95     4096    2 /home/thomas/directory (192.168.178.110:/LVM/directory)

Prozess killen der auf die device zugreift

fuser -km /home/thomas/directory
  • -k : Kill processes accessing the file.
  • -m : Name specifies a file on a mounted file system or a block device that is mounted.

Der Unterschied zwischen role_based_access_control und azure_active_directory_role_based_access_control liegt in der Art, wie die Zugriffssteuerung (RBAC) und die Integration von Azure Active Directory (AAD) im Azure Kubernetes Service (AKS) implementiert wird.

1. role_based_access_control

  • Dies aktiviert das native Kubernetes RBAC (Role-Based Access Control) innerhalb des AKS-Clusters.
  • Die azure_active_directory-Sektion innerhalb von role_based_access_control ermöglicht die Integration von Azure AD in das Kubernetes RBAC-System.
  • Zugriff wird durch Kubernetes-Rollen und RoleBindings/ClusterRoleBindings gesteuert.
  • Hier nutzt du Kubernetes-RBAC in Kombination mit Azure AD für die Authentifizierung.
  • Beispiel:
role_based_access_control {
  enabled = true

  azure_active_directory {
    managed                = true
    admin_group_object_ids = ["<aad-admin-group-object-id>"]
  }
}
  • Wann verwenden?
    • Wenn du Kubernetes-native RBAC mit Azure AD verwenden möchtest.
    • Für feingranulare Kontrolle auf Kubernetes-Ebene.

2. azure_active_directory_role_based_access_control

  • Dies aktiviert Azure RBAC für das AKS-Cluster.
  • Azure RBAC nutzt die Azure-Rollen (Contributor, Reader, Owner) und benutzerdefinierte Azure-Rollen, um Zugriffsrechte direkt in Azure zu steuern, ohne auf Kubernetes-RBAC angewiesen zu sein.
  • In Kombination mit azure_rbac_enabled = true wird Azure RBAC die einzige Methode zur Steuerung des Zugriffs.
  • Beispiel:
azure_active_directory_role_based_access_control {
  admin_group_object_ids = var.aks_admin_group_object_ids
  azure_rbac_enabled     = true
}

  • Wann verwenden?
    • Wenn du Zugriffskontrolle auf Azure-Ebene möchtest, ohne dich mit Kubernetes-RBAC beschäftigen zu müssen.
    • Für einfachere und zentralisierte Verwaltung durch Azure-Rollen.

Hauptunterschiede:

Featurerole_based_access_controlazure_active_directory_role_based_access_control
Typ der ZugriffssteuerungKubernetes RBAC mit Azure AD-IntegrationAzure RBAC (Azure-Rollen und -Berechtigungen)
GranularitätSehr fein granular (z. B. Zugriff auf einzelne Namespaces)Grob granular, basierend auf Azure-Rollen
KonfigurationsebeneInnerhalb des Kubernetes-ClustersInnerhalb von Azure
Komplexität der VerwaltungErfordert Kubernetes-spezifische KenntnisseEinfacher, da Azure RBAC in der Azure-Umgebung bleibt
Integration mit bestehenden SystemenIdeal, wenn du bereits Kubernetes-RBAC verwendestIdeal, wenn du vorhandene Azure-Rollen und Zugriffssteuerungen nutzt

Wann solltest du was verwenden?

  • Verwende role_based_access_control, wenn:
    • Du Kubernetes-native Zugriffssteuerung benötigst.
    • Du eine detaillierte, anwendungs- oder namespace-spezifische Steuerung wünschst.
  • Verwende azure_active_directory_role_based_access_control, wenn:
    • Du eine zentralisierte, einfache Zugriffssteuerung auf Azure-Ebene bevorzugst.
    • Du bereits Azure-Rollen und RBAC in deiner Organisation etabliert hast.

Kombination:

Du kannst nicht beide Methoden gleichzeitig aktivieren. Wähle die Methode, die am besten zu deinen Anforderungen passt.

4o

kubectl get secret postgres-credentials -o jsonpath="{.data}" | jq 'to_entries | .[] | "\(.key): \(.value | @base64d)"'
    3  apt install build-essential nasm make
    6  apt install libass-dev
   11  apt install libfdk-aac-dev
   14  apt install libmp3lame-dev
   17  apt install libopus-dev
   19  apt install libvorbis-dev
   21  apt install libvpx-dev
   23  apt install libx264-dev
   25  apt install libopenssl-dev
   27  apt install libssh-dev
./configure --disable-shared --enable-static --enable-pthreads --enable-gpl --enable-nonfree --enable-libass --enable-libfdk-aac --enable-libfreetype --enable-libmp3lame --enable-libopus --enable-libvorbis --enable-libvpx --enable-libx264 --enable-filters --enable-openssl --enable-runtime-cpudetect
tcpdump -i tun0 -nnv icmp

Das DF und none bei den Flags zeigt das keine Pakete fragmentiert wurden

tcpdump -i tun0 -nnv icmp
tcpdump: listening on tun0, link-type RAW (Raw IP), snapshot length 262144 bytes
22:14:05.758520 IP (tos 0x0, ttl 64, id 18144, offset 0, flags [DF], proto ICMP (1), length 1400)
    192.168.255.6 > 8.8.8.8: ICMP echo request, id 13003, seq 0, length 1380
22:14:05.793387 IP (tos 0x0, ttl 55, id 0, offset 0, flags [none], proto ICMP (1), length 1400)
    8.8.8.8 > 192.168.255.6: ICMP echo reply, id 13003, seq 0, length 1380
22:14:06.759979 IP (tos 0x0, ttl 64, id 18196, offset 0, flags [DF], proto ICMP (1), length 1400)
    192.168.255.6 > 8.8.8.8: ICMP echo request, id 13003, seq 1, length 1380
22:14:06.797614 IP (tos 0x0, ttl 55, id 0, offset 0, flags [none], proto ICMP (1), length 1400)
    8.8.8.8 > 192.168.255.6: ICMP echo reply, id 13003, seq 1, length 1380

Das + bei den Flags zeigt das Pakete fragmentiert wurden

tcpdump -i tun0 -nnv icmp
tcpdump: listening on tun0, link-type RAW (Raw IP), snapshot length 262144 bytes
22:14:59.515817 IP (tos 0x0, ttl 64, id 20153, offset 0, flags [+], proto ICMP (1), length 1396)
    192.168.255.6 > 8.8.8.8: ICMP echo request, id 13101, seq 0, length 1376
22:14:59.515855 IP (tos 0x0, ttl 64, id 20153, offset 1376, flags [none], proto ICMP (1), length 25)
    192.168.255.6 > 8.8.8.8: ip-proto-1

OpenVPN-Konfiguration initialisieren

dnf install iptables iptables-services
echo "tun" | sudo tee /etc/modules-load.d/tun.conf
modprobe tun
lsmod | grep tun


OVPN_DATA="ovpn-data"
docker volume create --name $OVPN_DATA
docker run -v $OVPN_DATA:/etc/openvpn --rm kylemanna/openvpn ovpn_genconfig -u udp://DEINE_VPN_SERVER_IP
docker run -v $OVPN_DATA:/etc/openvpn --rm -it kylemanna/openvpn ovpn_initpki

OpenVPN-Server starten

docker run -v $OVPN_DATA:/etc/openvpn -d -p 443:1194/udp --cap-add=NET_ADMIN kylemanna/openvpn

Client-Zertifikate erstellen

docker run --name openvpn -v $OVPN_DATA:/etc/openvpn \ 
-v /lib/modules/:/lib/modules \
-d -p 443:1194/udp \
--cap-add=NET_ADMIN \
--device /dev/net/tun \
--privileged \
--restart unless-stopped  kylemanna/openvpn

Client-Zertifikate erstellen

docker run -v $OVPN_DATA:/etc/openvpn --rm -it kylemanna/openvpn easyrsa build-client-full CLIENT_NAME nopass

Client-Konfigurationsdatei erstellen (ovpn)

docker run -v $OVPN_DATA:/etc/openvpn --rm kylemanna/openvpn ovpn_getclient CLIENT_NAME > CLIENT_NAME.ovpn
1 2 3 7