ryandaniels.iptables_docker

Aperçu Versions Perspectives

Rôle Ansible : iptables pour Docker (et Docker Swarm)

Ajoutez des règles de pare-feu à votre serveur via iptables pour Docker et Docker Swarm. Cela protégera réellement vos conteneurs Docker !
Ce rôle Ansible existe car firewalld et Docker (et Docker Swarm) ne fonctionnent pas bien ensemble.

Problème à résoudre : Lors du démarrage d'un conteneur dans Docker avec un port "publié", vous n'avez aucun contrôle et le port est exposé à travers le pare-feu de votre serveur. Même si vous utilisez iptables ou un autre pare-feu sur votre serveur, Docker ouvre ce port "publié" à tout le monde, contournant votre pare-feu.

Cas d'utilisation de cette solution : Permettre à des IP de confiance de se connecter aux conteneurs Docker (et aux conteneurs Docker Swarm), ainsi qu'à d'autres ports ouverts du système d'exploitation. Avec une option pour exposer certains ports au public (Docker/Docker Swarm et OS). Ces IP de confiance peuvent ne pas être dans la même plage IP réseau, ou même dans le même sous-réseau.

Cela était censé être simple. Sécurisez Docker avec un pare-feu. Mais malheureusement, ce n'est pas le cas. J'ai essayé de garder cela aussi simple que possible.

Il pourrait y avoir des problèmes inconnus avec cela... utilisez à vos risques et périls !

Voir aussi : https://ryandaniels.ca/blog/secure-docker-with-iptables-firewall-and-ansible/
Et à propos de l'utilisation par Docker de la chaîne INPUT : https://ryandaniels.ca/blog/docker-iptables-input-chain/

Actuellement testé et fonctionnel sur :

  • CentOS/RHEL 7
  • Ubuntu 18.04
  • Ubuntu 20.04

Caractéristiques

  • Fonctionne avec Docker et Docker Swarm (alias Docker SwarmKit).
  • Sécurisé par défaut. Une fois configuré, seules les IP de Docker peuvent accéder à tous les conteneurs et tous les autres processus du système d'exploitation ayant des ports ouverts sur le serveur.
  • Aussi simple que possible. Moins il y a de règles iptables, meilleures seront les performances (du moins en théorie).
  • Automatique. Pas besoin d'ajouter manuellement des ports à la configuration du pare-feu (si vous utilisez un ensemble d'IP de confiance).
  • Ajoutez des IP "de confiance" qui sont autorisées à communiquer avec tous les conteneurs Docker et tous les autres processus du système d'exploitation ayant des ports ouverts sur le serveur.
  • Ouvrez les ports de conteneur Docker spécifiés, ou les ports OS du serveur au public (tout le monde) via le pare-feu, comme SSH.
  • Les interfaces peuvent également être spécifiées. Par défaut, toutes les interfaces sont filtrées. Vous pouvez filtrer des interface(s) réseau spécifiques et autoriser toutes les autres interfaces (il suffit de spécifier une interface non fiable).
  • Tout est fait en mode "hors ligne". Donc, il ne devrait y avoir aucun problème avec Docker lorsque les règles iptables sont activées.
  • Vous n'avez pas besoin d'être un expert en iptables pour utiliser cela.
  • Fonctionne avec l'utilisation non documentée d'iptables et des réseaux superposés chiffrés de Docker Swarm. (les règles iptables sont ajoutées à la chaîne INPUT).

Cette solution utilise iptables comme pare-feu et ipset pour permettre à iptables d'avoir une liste d'IP autorisées. ipset vous permet également d'utiliser une plage d'IP non continue.

Chaînes iptables utilisées et comment :
INPUT, non vidé. Règle insérée en haut pour sauter vers une chaîne personnalisée pour les règles liées à l'OS.
DOCKER-USER, vidé. Toutes les règles liées à Docker (et Docker Swarm) se trouvent ici pour bloquer par défaut l'exposition des conteneurs à tout le monde. Par défaut, seules les IPs du serveur Docker sont autorisées. D'autres IP et ports de conteneurs peuvent être ajoutés par l'utilisateur.
FILTERS, vidé. Chaîne personnalisée pour les processus du serveur (qui ne sont pas Docker). Par défaut, seules les IPs du serveur Docker sont autorisées. D'autres IP et ports de conteneurs peuvent être ajoutés par l'utilisateur.

Manuel iptables : http://ipset.netfilter.org/iptables.man.html

Avertissements

Ne vous enfermez pas hors de votre serveur. Cela modifie votre pare-feu. Ayez toujours un autre moyen d'accéder, comme une "console".

Note sur les IPs : Cela concerne uniquement IPv4. IPv6 n'a pas été testé. Il est plus sûr de désactiver IPv6 sur vos serveurs.

Autre considération de sécurité :
Si vous utilisez Docker non-Swarm (normal), envisagez également de lier un port à une IP interne pour une meilleure sécurité.
Si vous utilisez Swarm, envisagez d'utiliser des IP spécifiques pour la communication Docker Swarm.
Ex. docker swarm init --advertise-addr 192.168.100.100 --listen-addr=192.168.100.100 --data-path-addr=192.168.100.100

Note importante : Docker et firewalld ne fonctionnent pas bien ensemble. Ce rôle Ansible vérifie si le service firewalld est en cours d'exécution ou activé et échoue si c'est le cas.
Pour plus d'informations sur firewalld et Docker :
https://success.docker.com/article/why-am-i-having-network-problems-after-firewalld-is-restarted
https://www.tripwire.com/state-of-security/devops/psa-beware-exposing-ports-docker/
https://docs.docker.com/network/iptables/

Bug SELinux :
Actuellement, il y a un bug avec SELinux qui empêche la sauvegarde des règles iptables dans le fichier iptables.save.
Impact : La deuxième sauvegarde des règles iptables échouera silencieusement.
Un contournement a été ajouté pour que SELinux permette à chmod d'interagir avec le fichier iptables.save.
Alternativement, vous pourriez désactiver SELinux, mais cela n'est pas recommandé.
Rapport de bug : https://bugs.centos.org/view.php?id=12648
Voir ci-dessous pour plus de détails sur la mise en œuvre manuelle du contournement.

AVERTISSEMENT :
Assurez-vous de tester d'abord dans un environnement non productif, je ne peux garantir quoi que ce soit ni être tenu responsable.
Faites attention, cela supprimera et ajoutera des règles iptables sur le système d'exploitation. Utilisez avec prudence.
Les règles iptables existantes pourraient être supprimées ! Confirmez votre configuration avant d'exécuter cela.

Il pourrait y avoir des problèmes inconnus avec cela... utilisez à vos risques et périls !

Versions de Docker testées

Docker Engine - Community Edition version :

  • 19.03.8
  • 19.03.9
  • 19.03.12

Testé en mode Docker normal et avec un cluster Docker Swarm de 3 nœuds.

Distributions testées

  • CentOS : 7.7, 7.8
  • Ubuntu 18.04
  • Ubuntu 20.04

Dépendances

  • iptables et iptables-services

Testé avec v1.4.21 (dernière version disponible dans CentOS 7)

  • ipset et ipset-service

Testé avec v7.1 (dernière version disponible dans CentOS 7)

Paramètres par défaut

  • Activer le débogage
debug_enabled_default: false
  • Proxy (nécessaire lors de l'installation des packages requises si derrière un proxy)
proxy_env: []
  • Rôle désactivé par défaut. Changez à true dans group_vars ou playbook, etc.
iptables_docker_managed: false
  • Vérifiez si le service (Docker) est en cours d'exécution ou activé, et échouez le rôle.
iptables_docker_check_problem_service_managed: true
  • Services à vérifier, et échouer le rôle.
iptables_docker_check_problem_service:
  - docker.service
  • Affichez la configuration des variables.
iptables_docker_show_config: true
  • Démarrez le service iptables.
iptables_docker_start: true
  • Installez le package iptables.
iptables_docker_managed_pkg: true
iptables_docker_packages:
  - iptables
  - iptables-services
  - ipset
  - ipset-service
  - policycoreutils-python # requis pour semodule
  • Forcer la copie du fichier ipset pour déclencher le rechargement ipset.
iptables_docker_copy_ipset_force: false
  • Forcer la copie du fichier iptables pour déclencher le rechargement iptables.
iptables_docker_copy_iptables_force: false
  • Emplacement de la configuration iptables sauvegardée.
iptables_docker_iptables_config_save: /etc/sysconfig/iptables
  • Emplacement de la configuration ipset sauvegardée.
iptables_docker_ipset_config_dir: /etc/sysconfig/ipset.d

  • Nombre maximum d'éléments ipset (IPs dans la liste autorisée).

    Si changé après la première création, doit être supprimé et recréé manuellement. 64k IPs devraient suffire.

iptables_docker_ipset_maxelem: 65536

Paramètres Utilisateur

  • Remplacer les IPs du serveur Docker (optionnel).

    Vous pouvez spécifier les IPs du serveur Docker. Si non défini, les IPs seront déterminées à partir du groupe docker_hosts dans l'inventaire Ansible.

# iptables_docker_server_ip_allow_set:
#   - 192.168.100.100
#   - 192.168.100.101
#   - 192.168.100.102
  • IPs autorisées à utiliser tous les ports exposés des conteneurs Docker et tous les ports exposés des processus du serveur.
# iptables_docker_ip_allow_set: []
iptables_docker_ip_allow_set:
  - 192.168.100.1
  - 192.168.101.0/24
  - 192.168.102.0/24

  • Adaptateur réseau à restreindre pour les règles OS.

    Seuls les adaptateurs listés seront bloqués. Les autres seront autorisés. Par défaut, tout est bloqué (avec '+').
    Si vous souhaitez restreindre uniquement une interface réseau spécifique, utilisez le nom exact.
    Si vous souhaitez restreindre toutes les interfaces du même type, utilisez "interface+" pour faire correspondre chaque interface, puisque + est le caractère générique pour iptables.
    Ex. Pour restreindre les interfaces ethX, utilisez "eth+". "eth+" est un caractère générique pour tout ce qui commence par eth.
    NE PAS utiliser "*". Ce n'est pas un caractère générique et ne correspond à rien !
    Moins il y a ici, mieux c'est. Mieux vaut bloquer tout ('+') mais si ce n'est pas possible, ajoutez d'abord les adaptateurs réseau avec un trafic élevé.
    local (lo) n'est pas nécessaire ici.

iptables_docker_external_network_adapter:
  - "+" # Caractère générique pour tout
  # - "eth+"
  # - "enp0s+"
  # - "wlp1s+"

  • Ports TCP du système d'exploitation ouverts au public.

    Ports autorisés à tous les utilisateurs de se connecter (seront accessibles au public). Les ports ici autoriseront tout le trafic TCP vers ces ports depuis le niveau iptables.
    Seulement pour les ports sur le système d'exploitation, pas pour les conteneurs Docker.

iptables_docker_global_ports_allow_tcp:
  - 22                   # SSH

  • Ports UDP du système d'exploitation ouverts au public.

    Ports autorisés à tous les utilisateurs de se connecter (seront accessibles au public). Les ports ici autoriseront tout le trafic UDP vers ces ports depuis le niveau iptables.
    Seulement pour les ports sur le système d'exploitation, pas pour les conteneurs Docker.

iptables_docker_global_ports_allow_udp: []

  • Adaptateur réseau à restreindre pour les règles Docker.

    Par défaut, utilise la même configuration que l'adaptateur réseau pour le système d'exploitation.

iptables_docker_swarm_network_adapter: "{{ iptables_docker_external_network_adapter }}"
# iptables_docker_swarm_network_adapter:
#   - "+" # Caractère générique pour tout
#   # - "eth+"

  • Ports TCP des conteneurs Docker ouverts au public.

    Ajoutez les ports TCP des conteneurs Docker que vous souhaitez ouvrir à tous. Pour Docker et Docker Swarm. Les ports de Docker Swarm ne sont pas nécessaires ici.

iptables_docker_swarm_ports_allow_tcp: []
# iptables_docker_swarm_ports_allow_tcp:
#   - 9000

  • Ports UDP des conteneurs Docker ouverts au public.

    Ajoutez les ports UDP des conteneurs Docker que vous souhaitez ouvrir à tous. Pour Docker et Docker Swarm. Les ports de Docker Swarm ne sont pas nécessaires ici.

iptables_docker_swarm_ports_allow_udp: []
  • Nom du réseau de pont Docker (docker0) et plage IP (pour l'autorisation de source iptables DOCKER-USER).
iptables_docker_bridge_name: docker0
iptables_docker_bridge_ips: 172.17.0.0/16
  • Plage IP du réseau de pont Docker Swarm (docker_gwbridge) (pour l'autorisation de source iptables DOCKER-USER).
iptables_docker_swarm_bridge_name: docker_gwbridge
iptables_docker_swarm_bridge_ips: 172.18.0.0/16

Exemple de fichier de configuration (inventories/dev-env/group_vars/all.yml)

Dans l'exemple ci-dessous :
Les IPs seront ajoutées à la liste de confiance :

  • 192.168.100.1
  • 192.168.101.0/24

Tous les adaptateurs réseau seront restreints car un caractère générique '+' est utilisé pour iptables_docker_external_network_adapter.

Le port 22 sera ouvert au public.

---
iptables_docker_ip_allow_set:
  - 192.168.100.1
  - 192.168.101.0/24

iptables_docker_external_network_adapter:
  - "+" # Caractère générique pour tout

iptables_docker_global_ports_allow_tcp:
  - 22                   # SSH

Exemple de fichier d'inventaire

[docker_hosts]
centoslead1 ansible_host=192.168.100.100
centoswork1 ansible_host=192.168.100.101
centoswork2 ansible_host=192.168.100.102

Exemple de Playbook iptables_docker.yml

---
- hosts: '{{ inventory }}'
  become: yes
  vars:
    # Utilisez ce rôle
    iptables_docker_managed: true
  roles:
  - ryandaniels.iptables_docker

Utilisation

Avant d'exécuter, vérifiez si vous utilisez déjà iptables ! Rien ne devrait être écrasé/supprimé, sauf si vous utilisez les mêmes chaînes iptables que celles-ci.

Par défaut, aucune tâche ne s'exécutera sauf si vous définissez iptables_docker_managed=true. Cela est fait pour éviter des accidents par des personnes qui ne lisent pas la documentation.

ansible-playbook iptables_docker.yml --extra-vars "inventory=centos7 iptables_docker_managed=true" -i hosts-dev

Sauter l'installation des packages (si déjà connus - accélère la tâche).

ansible-playbook iptables_docker.yml --extra-vars "inventory=centos7 iptables_docker_managed=true" -i hosts --skip-tags=iptables_docker_pkg_install

Afficher des informations plus détaillées (infos de débogage).

ansible-playbook iptables_docker.yml --extra-vars "inventory=centos7 iptables_docker_managed=true debug_enabled_default=true" -i hosts-dev

Ne pas démarrer le service iptables ou ajouter de règles pour iptables.

ansible-playbook iptables_docker.yml --extra-vars "inventory=centos7 iptables_docker_managed=true iptables_docker_start=false" -i hosts-dev

Forcer ipset et iptables à se mettre à jour.

ansible-playbook iptables_docker.yml --extra-vars "inventory=centos7 iptables_docker_managed=true iptables_docker_copy_ipset_force=true iptables_docker_copy_iptables_force=true" -i hosts-dev

Afficher uniquement la configuration (des variables).

ansible-playbook iptables_docker.yml --extra-vars "inventory=centos7 iptables_docker_managed=true iptables_docker_show_config=true" -i hosts --tags "iptables_docker_show_config"

Note sur la limite de taille d'ipset

Important : Faites attention à la taille de "Nombre d'entrées". Si ce nombre est proche de la taille maximale (65536), vous devez supprimer l'ipset "ip_allow" et le recréer avec une taille maximale plus grande.
64K devrait suffire à n'importe qui.

Le fichier se trouve dans : templates/ip_allow.set.j2

create -exist ip_allow hash:ip family inet hashsize 1024 maxelem 65536

Vérifiez la taille de la liste ipset :

ipset list |grep "Nombre d'entrées"

Sortie importante :

Nombre d'entrées : 3

Contournement manuel SELinux pour iptables et chmod

Détails du bug : https://bugs.centos.org/view.php?id=12648

Le problème survient lors de la sauvegarde des iptables une 2ème fois, SELinux bloque cela puisque chmod a un problème avec le fichier iptables.save.
Utilisez cet exemple comme contournement pour permettre à chmod de modifier le fichier iptables.save s'il n'est pas utilisé avec le rôle Ansible.
Pour reproduire, redémarrez le service iptables après avoir défini la configuration iptables à sauvegarder après le redémarrage/arrêt,

yum install audit policycoreutils policycoreutils-python
ausearch -m AVC,USER_AVC,SELINUX_ERR,USER_SELINUX_ERR -i|tail -55
ausearch -c 'chmod' --raw | audit2allow -M iptables_save_chmod
#ou grep "iptables.save" /var/log/audit/audit.log|tail | audit2allow -M iptables_save_chmod
semodule -i iptables_save_chmod.pp

Référence de commande iptables

Plus de commandes peuvent être trouvées dans la documentation iptables : http://ipset.netfilter.org/iptables.man.html

Lister les iptables qui sont actifs :

iptables -nvL --line-numbers

Commandes utiles CentOS/RHEL :

cat /etc/sysconfig/ipset.d/ip_allow.set
systemctl restart ipset
ipset list | head

iptables -F DOCKER-USER
iptables -F FILTERS
iptables-restore -n < ansible_iptables_docker-iptables

grep -v "^#" ansible_iptables_docker-iptables
iptables -S INPUT
iptables -S DOCKER-USER
iptables -S FILTERS

Commandes utiles Ubuntu :

vi /etc/iptables/ipsets
#Ajoutez manuellement 'flush' avant d'ajouter, si vous retirez des IPs manuellement.

sudo /usr/sbin/netfilter-persistent reload

cat /etc/iptables/ipsets

cat /etc/iptables/rules.v4

Commandes manuelles (CentOS/RHEL)

Vérifiez quelles règles iptables vous avez déjà. Prenez note au cas où elles seraient perdues !

iptables -nvL --line-numbers

Installez les packages requis :

yum install iptables iptables-services ipset ipset-service

Si vous utilisez SELinux, installez également :

yum install policycoreutils-python

Configurez ipset avec vos IPs de serveur et autres IPs de confiance :

mkdir -p /etc/sysconfig/ipset.d
cat > /etc/sysconfig/ipset.d/ip_allow.set  << 'EOF'
create -exist ip_allow hash:ip family inet hashsize 1024 maxelem 65536
add ip_allow 192.168.1.123
add ip_allow 192.168.101.0/24
add ip_allow 192.168.102.0/24
EOF

Démarrez et activez le service ipset :

systemctl status ipset
systemctl start ipset
systemctl enable ipset

Voir ce que ipset a dans sa configuration chargée :

ipset list | head

Les règles iptables ajoutées (par défaut le port 22 est ouvert à tout le monde) :

cat > ansible_iptables_docker-iptables << 'EOF'
*filter
:DOCKER-USER - [0:0]
:FILTERS - [0:0]
#Impossible de vider INPUT. Cependant, cela efface les règles Docker Swarm.
#-F INPUT
#Utilisez ansible ou exécutez manuellement une fois pour ajouter -I INPUT -j FILTERS
#-I INPUT -j FILTERS
-A DOCKER-USER -m state --state RELATED,ESTABLISHED -j RETURN
-A DOCKER-USER -i docker_gwbridge -j RETURN
-A DOCKER-USER -s 172.18.0.0/16 -j RETURN
-A DOCKER-USER -i docker0 -j RETURN
-A DOCKER-USER -s 172.17.0.0/16 -j RETURN
#Les ports Docker ci-dessous sont ouverts à tous s'ils sont décommentés.
#-A DOCKER-USER -p tcp -m tcp -m multiport --dports 8000,8001 -j RETURN
#-A DOCKER-USER -p udp -m udp -m multiport --dports 9000,9001 -j RETURN
-A DOCKER-USER -m set ! --match-set ip_allow src -j DROP
-A DOCKER-USER -j RETURN
-F FILTERS
#À cause du réseau superposé chiffré Docker Swarm, il suffit d'ajouter des règles à INPUT. Doit être en haut malheureusement.
-A FILTERS -p udp -m policy --dir in --pol ipsec -m udp --dport 4789 -m set --match-set ip_allow src -j RETURN
-A FILTERS -m state --state RELATED,ESTABLISHED -j ACCEPT
-A FILTERS -p icmp -j ACCEPT
-A FILTERS -i lo -j ACCEPT
#Les ports OS ci-dessous sont ouverts à tous s'ils sont décommentés.
-A FILTERS -p tcp -m state --state NEW -m tcp -m multiport --dports 22 -j ACCEPT
#-A FILTERS -p udp -m udp -m multiport --dports 53,123 -j ACCEPT
-A FILTERS -m set ! --match-set ip_allow src -j DROP
-A FILTERS -j RETURN
COMMIT

EOF

Utilisez iptables-restore pour ajouter les règles ci-dessus dans iptables. Le drapeau très important est -n. Cela garantit que nous ne versons pas les règles iptables si nous avons déjà des règles dans Docker (ou Docker Swarm).

iptables-restore -n < ansible_iptables_docker-iptables

Ensuite, ajoutez une règle à la chaîne INPUT, pour que nous commencions à utiliser les nouvelles règles dans FILTERS. Cela doit être en haut et ne doit être ajouté qu'une fois :

iptables -I INPUT 1 -j FILTERS

Sauvegardez les règles iptables :

/usr/libexec/iptables/iptables.init save

Démarrez et activez le service iptables :

systemctl status iptables
systemctl start iptables
systemctl enable iptables

Si vous souhaitez personnaliser les règles iptables pour autoriser plus de ports à être ouverts à tout le monde, ajoutez simplement le port à la règle appropriée dans le fichier iptables (tcp ou udp), puis réexécutez les mêmes commandes ci-dessus :

iptables-restore -n < ansible_iptables_docker-iptables
/usr/libexec/iptables/iptables.init save

Ne manquez pas les Avertissements ci-dessus ! Surtout à propos de SELinux.

Commandes manuelles (Ubuntu 20.04)

Vérifiez quelles règles iptables vous avez déjà. Prenez note au cas où elles seraient perdues !
Ubuntu 18.04 est presque identique. Sauf que le package ipset-persistent n'existe pas dans Ubuntu 18.04, donc omettez ce package et copiez les fichiers de files/ubuntu/iptables-persistent*/plugins/*-ipset dans /usr/share/netfilter-persistent/plugins.d/. 

iptables -nvL --line-numbers

Installez les packages requis :

apt install iptables iptables-persistent netfilter-persistent ipset ipset-persistent

Configurez ipset avec vos IPs de serveur et autres IPs de confiance :

mkdir -p /etc/iptables
cat > /etc/iptables/ipsets  << 'EOF'
create -exist ip_allow hash:ip family inet hashsize 1024 maxelem 65536
flush
add ip_allow 192.168.1.123
add ip_allow 192.168.101.0/24
add ip_allow 192.168.102.0/24
EOF

Rechargez ipset :

sudo /usr/sbin/netfilter-persistent reload

Vérifiez ce que ipset a dans sa configuration chargée :

ipset list | head

Les règles iptables ajoutées (par défaut le port 22 est ouvert à tout le monde) :

Utilisez la même commande que ci-dessus pour CentOS/RHEL.

Utilisez iptables-restore pour ajouter les règles ci-dessus dans iptables. Le drapeau très important est -n. Cela garantit que nous ne versons pas les règles iptables si nous avons déjà des règles dans Docker (ou Docker Swarm).

iptables-restore -n < ansible_iptables_docker-iptables

Ensuite, ajoutez une règle à la chaîne INPUT, pour que nous commencions à utiliser les nouvelles règles dans FILTERS. Cela doit être en haut et ne doit être ajouté qu'une fois :

iptables -I INPUT 1 -j FILTERS

Sauvegardez les règles iptables :

sudo /usr/sbin/netfilter-persistent save

Démarrez et activez le service iptables :

systemctl status netfilter-persistent
systemctl start netfilter-persistent
systemctl enable netfilter-persistent

Si vous souhaitez personnaliser les règles iptables pour permettre plus de ports à être ouverts à tout le monde, ajoutez simplement le port à la règle appropriée dans le fichier iptables (tcp ou udp), puis réexécutez les mêmes commandes ci-dessus :

iptables-restore -n < ansible_iptables_docker-iptables
/usr/sbin/netfilter-persistent save

Ne manquez pas les Avertissements ci-dessus !

À FAIRE

  • Vérifier firewalld et échouer s'il est en cours d'exécution ou activé.
  • Problème avec la sauvegarde des règles Docker dans iptables ? Cela devrait aller.
  • iptables_docker_ip_allow_set ne peut pas être vide. Si c'est le cas, cela n'a pas de sens puisque rien n'est bloqué !
  • ajouter une vérification dans les adaptateurs réseau pour * et erreur.
  • ajouter une liste automatique des IPs docker dans la liste autorisée (utilise les IPs du groupe dans l'inventaire docker_hosts).
  • Modifier les IPs de confiance pour le serveur Docker afin de pouvoir les remplacer.
  • confirmer que "when" et "tags" sont bons.
  • Ubuntu ? Ubuntu n'a pas d'iptables-services ni d'ipset-service. A iptables-persistent et ipset-? Pas de support ufw.
  • ipv6 ?? Ceci est uniquement pour ipv4.
  • tester si TCP, UDP fonctionnent pour les ports des conteneurs Docker et OS.
  • tester si le trafic sortant des conteneurs Docker fonctionne.
  • ajouter un test ? Molécule ? Mode Swarm à nœud unique seulement ? Comment tester qu'une connexion ne fonctionne pas depuis une IP "non fiable" ?

Auteur

Ryan Daniels

À propos du projet

Manage iptables configuration to secure Docker (including Docker Swarm).

role docker iptables networking port security swarm system tcp
Installer
ansible-galaxy install ryandaniels.iptables_docker
GitHub référentiel
26 étoiles
7 forks
0 problèmes ouverts
Licence
mit
Téléchargements
2.7k
Propriétaire
Ryan Daniels
Ansible all the things