Comment sécuriser votre cluster CoreOS avec les règles TLS / SSL et de pare-feu

introduction

Si vous envisagez d’exécuter un cluster CoreOS dans un environnement réseau indépendant de votre contrôle, tel qu’un centre de données partagé ou un accès Internet public, vous avez peut-être remarqué que + etcd + communique en effectuant des demandes HTTP non chiffrées. Il est possible d’atténuer les risques de ce comportement en configurant un pare-feu IPTables sur chaque nœud du cluster, mais une solution complète utiliserait idéalement une couche de transport chiffrée.

Heureusement, + etcd + prend en charge les connexions TLS / SSL entre homologues, de sorte que chaque membre d’un cluster est authentifié et que toutes les communications sont cryptées. Dans ce guide, nous allons commencer par provisionner un cluster simple avec trois membres, puis configurer les points de terminaison HTTPS et un pare-feu de base sur chaque ordinateur.

Conditions préalables

Ce guide s’appuie fortement sur les concepts abordés dans les this introduction aux composants du système CoreOS et https: //www.digitalocean. com / communauté / didacticiels / comment-configurer-un-cluster-sur-digitalocean [ce guide pour la mise en place d’un cluster CoreOS sur DigitalOcean].

Vous devez être familiarisé avec les bases des fichiers + etcd,` + fleetctl`, + cloud-config et à la génération d’une URL de découverte.

Pour créer et accéder aux machines de votre cluster, vous aurez besoin d’une clé publique SSH associée à votre compte DigitalOcean. Pour plus d’informations sur l’utilisation des clés SSH avec DigitalOcean, consultez la page voir ici.

Si vous souhaitez utiliser l’API DigitalOcean pour créer vos machines CoreOS, reportez-vous à la page https://www.digitalocean.com/community/tutorials/how-to-use-the-digitalocean-api-v2#how-to-generate- a-personal-access-token [ce didacticiel] pour plus d’informations sur la création et l’utilisation d’un jeton d’accès personnel avec des autorisations en écriture. L’utilisation de l’API est facultative, mais peut vous faire gagner du temps à long terme, en particulier si vous envisagez de créer de plus grands clusters.

Générer une nouvelle URL de découverte

Récupérez une nouvelle URL de découverte dans discovery.etcd.io, soit en visitant https://discovery.etcd.io/new?size=3 dans votre navigateur et en copiant l’URL affichée, soit en utilisant + curl + à partir du terminal votre machine locale:

curl -w "\n" "https://discovery.etcd.io/new?size=3"

Enregistrez l’URL renvoyée. nous allons l’utiliser dans notre + cloud-config + prochainement.

Écrire un fichier Cloud-Config incluant la configuration HTTPS

Nous allons commencer par écrire un + cloud-config. Le + cloud-config + sera fourni en tant que * données utilisateur * lors de l’initialisation de chaque serveur, définissant les détails de configuration importants pour le cluster. Ce fichier sera long, mais ne devrait pas être beaucoup plus compliqué que la version disponible dans la https://www.digitalocean.com/community/tutorials/how-to-set-up-a-coreos-cluster-on- digitalocean [guide de base des clusters]. Nous indiquerons explicitement à + flotte + de se servir des points de terminaison HTTPS, d’activer un service appelé + iptables-restore + pour notre pare-feu et d’écrire des fichiers de configuration indiquant «+ etcd » et « flotte +» où trouver les certificats SSL.

Ouvrez un terminal sur votre ordinateur local, assurez-vous de vous trouver dans votre répertoire personnel et utilisez + nano + (ou votre éditeur de texte favori) pour créer et ouvrir + ~ / cloud-config.yml +:

cd ~
nano cloud-config.yml

Collez le texte suivant, puis remplacez ++ dans la section + etcd2 + par l’URL de découverte que vous avez indiquée dans la dernière section.

Vous pouvez également supprimer la section + iptables-restore +, si vous ne souhaitez pas activer un pare-feu.

Soyez prudent avec l’indentation lors du collage. Le + cloud-config + est écrit en YAML, qui est sensible aux espaces blancs. Consultez les commentaires dans le fichier pour plus d’informations sur des lignes spécifiques. Nous passerons ensuite en revue certaines sections importantes plus en détail.

~ / cloud-config.yml

#cloud-config

coreos:
 etcd2:
   # generate a new token for each unique cluster from https://discovery.etcd.io/new:
   discovery:
   # multi-region deployments, multi-cloud deployments, and Droplets without
   # private networking need to use $public_ipv4:
   advertise-client-urls: https://$private_ipv4:2379,https://$private_ipv4:4001
   initial-advertise-peer-urls: https://$private_ipv4:2380
   # listen on the official ports 2379, 2380 and one legacy port 4001:
   listen-client-urls: https://0.0.0.0:2379,https://0.0.0.0:4001
   listen-peer-urls: https://$private_ipv4:2380
 fleet:
   # fleet defaults to plain HTTP - explicitly tell it to use HTTPS on port 4001:
   etcd_servers: https://$private_ipv4:4001
   public-ip: $private_ipv4   # used for fleetctl ssh command
 units:
   - name: etcd2.service
     command: start
   - name: fleet.service
     command: start




write_files:
 # tell etcd2 and fleet where our certificates are going to live:
 - path: /run/systemd/system/etcd2.service.d/30-certificates.conf
   permissions: 0644
   content: |
     [Service]
     # client environment variables
     Environment=ETCD_CA_FILE=/home/core/ca.pem
     Environment=ETCD_CERT_FILE=/home/core/coreos.pem
     Environment=ETCD_KEY_FILE=/home/core/coreos-key.pem
     # peer environment variables
     Environment=ETCD_PEER_CA_FILE=/home/core/ca.pem
     Environment=ETCD_PEER_CERT_FILE=/home/core/coreos.pem
     Environment=ETCD_PEER_KEY_FILE=/home/core/coreos-key.pem
 - path: /run/systemd/system/fleet.service.d/30-certificates.conf
   permissions: 0644
   content: |
     [Service]
     # client auth certs
     Environment=FLEET_ETCD_CAFILE=/home/core/ca.pem
     Environment=FLEET_ETCD_CERTFILE=/home/core/coreos.pem
     Environment=FLEET_ETCD_KEYFILE=/home/core/coreos-key.pem

Vous pouvez également coller votre + cloud-config + dans the Validator officiel de CoreOS Cloud puis appuyez sur * Validate Cloud-Config *.

Enregistrez le fichier et quittez. Dans + nano +, vous pouvez accomplir cela avec * Ctrl-X * pour quitter, * y * pour confirmer l’écriture du fichier et * Entrée * pour confirmer le nom du fichier à enregistrer.

Voyons quelques blocs spécifiques de + cloud-init.yml +. Premièrement, les valeurs + flotte +:

 fleet:
   # fleet defaults to plain HTTP - explicitly tell it to use HTTPS:
   etcd_servers: https://$private_ipv4:4001
   public-ip: $private_ipv4   # used for fleetctl ssh command

Notez que + etcd_servers + est défini sur une URL + https +. Pour un fonctionnement HTTP simple, cette valeur n’a pas besoin d’être définie. Sans configuration explicite, cependant, HTTPS échouera. (+ $ private_ipv4 + est une variable comprise par le processus d’initialisation CoreOS, vous ne devez pas la modifier.)

Nous arrivons ensuite au bloc + write_files +. Les valeurs sont décomposées en un système de fichiers + chemin,` + autorisations` et + contenus, qui contient le contenu souhaité d’un fichier. Ici, nous spécifions que les fichiers unité + + systemd + des services + etcd2 + et + flotte + `doivent configurer des variables d’environnement pointant vers les certificats TLS / SSL que nous allons générer:

write_files:
 # tell etcd2 and fleet where our certificates are going to live:
 - path: /run/systemd/system/etcd2.service.d/30-certificates.conf
   permissions: 0644
   content: |
     [Service]
     # client environment variables
     Environment=ETCD_CA_FILE=/home/core/ca.pem
     ...
 - path: /run/systemd/system/fleet.service.d/30-certificates.conf
   permissions: 0644
   content: |
     [Service]
     # client auth certs
     Environment=FLEET_ETCD_CAFILE=/home/core/ca.pem
     ...

Bien que nous disions aux services où trouver les fichiers de certificat, nous ne pouvons pas encore fournir les fichiers eux-mêmes. Pour cela, nous devons connaître l’adresse IP privée de chaque ordinateur CoreOS, qui n’est disponible qu’une fois que les ordinateurs ont été créés.

Gouttelettes de provision

Maintenant que nous avons défini un + cloud-config.yml +, nous allons l’utiliser pour provisionner chaque membre du cluster. DigitalOcean propose deux approches de base: via le panneau de commande Web ou en appelant l’API DigitalOcean à l’aide de cURL à partir de la ligne de commande.

Utilisation du panneau de configuration DigitalOcean

Créez trois nouvelles gouttelettes CoreOS dans la même région de centre de données. Assurez-vous de cocher * Réseau privé * et * Activer les données utilisateur * à chaque fois.

  • * coreos-1 *

  • * coreos-2 *

  • * coreos-3 *

Dans le champ * User Data *, collez le contenu de + cloud-config.yml + ci-dessus, en vous assurant que vous avez inséré votre URL de découverte dans le champ + discovery + situé en haut du fichier.

Utilisation de l’API DigitalOcean

Comme approche alternative qui peut sauver le collage répétitif dans les champs, nous pouvons écrire un court script Bash qui utilise + curl + pour demander un nouveau Droplet à l’API DigitalOcean avec notre + cloud-config +, et l’invoquer une fois pour chaque Droplet. . Ouvrez un nouveau fichier appelé + makecoreos.sh + avec + nano + (ou votre éditeur de texte de choix):

cd ~
nano makecoreos.sh

Collez et enregistrez le script suivant en ajustant les champs + region + et + + size + comme vous le souhaitez pour votre cluster (les valeurs par défaut de + nyc3 + et + 512mb + `conviennent pour une démonstration, Droplets de région ou de plus grande taille pour des projets réels):

~ / makecoreos.sh

#!/usr/bin/env bash

# A basic Droplet create request.
curl -X POST "https://api.digitalocean.com/v2/droplets" \
    -d'{"name":"'"$1"'","region":"","size":"","private_networking":true,"image":"coreos-stable","user_data":
"'"$(cat ~/cloud-config.yml)"'",
        "ssh_keys":[ "'$DO_SSH_KEY_FINGERPRINT'" ]}' \
    -H "Authorization: Bearer $TOKEN" \
    -H "Content-Type: application/json"

Définissons maintenant les variables d’environnement + $ DO_SSH_KEY_FINGERPRINT + et + $ TOKEN + sur l’empreinte d’une clé SSH associée à votre compte DigitalOcean et à votre jeton d’accès personnel à l’API, respectivement.

Pour plus d’informations sur l’obtention d’un jeton d’accès personnel et l’utilisation de l’API, consultez this tutorial.

Afin de trouver l’empreinte d’une clé associée à votre compte, consultez the * Security * section des paramètres de votre compte, sous * SSH Keys *. Ce sera sous la forme d’une empreinte digitale de clé publique], quelque chose comme `+43: 51: 43: a1: b5: fc: 8b: b7: 0a: 3a : a9: b1: 0f: 66: 73: a8 + `.

Nous utilisons + export + ici pour que les processus enfants du shell, comme + makecoreos.sh +, puissent accéder aux variables. Les deux doivent être définis dans le shell actuel chaque fois que le script est utilisé, sinon l’appel d’API échouera:

export DO_SSH_KEY_FINGERPRINT=""
export TOKEN=""

Une fois que nous avons défini les variables d’environnement pour chacune des informations d’identification requises, nous pouvons exécuter le script pour créer chaque Droplet souhaité. + makecoreos.sh + utilise son premier paramètre pour renseigner le champ + name + dans son appel à l’API:

bash makecoreos.sh coreos-1
bash makecoreos.sh coreos-2
bash makecoreos.sh coreos-3

Vous devriez voir une sortie JSON décrivant chaque nouveau Droplet et les trois devraient apparaître dans votre liste de gouttelettes dans le Panneau de configuration. Cela peut prendre quelques secondes à la fin du démarrage.

Connectez-vous à coreos-1

Que vous utilisiez le Panneau de configuration ou l’API, vous devriez maintenant avoir trois Droplets en cours d’exécution. Il est maintenant temps de noter leurs adresses IP publiques et privées, disponibles en cliquant sur un droplet individuel dans le panneau de configuration, puis en cliquant sur le lien * Paramètres *. L’adresse IP privée de chaque Droplet sera nécessaire lors de la génération de certificats et de la configuration d’un pare-feu.

Testons une gouttelette. Assurez-vous que votre clé SSH est ajoutée à votre agent SSH local:

eval $(ssh-agent)
ssh-add

Recherchez l’adresse IP publique de * coreos-1 * dans le panneau de configuration de DigitalOcean et connectez-vous avec le transfert de l’agent SSH activé:

ssh -A core@

Lors de la première connexion à un membre du cluster, nous allons probablement recevoir un message d’erreur de + systemd +:

OutputCoreOS stable (766.5.0)
Failed Units: 1
 iptables-restore.service

Cela indique que le pare-feu n’a pas encore été configuré. Pour le moment, il est prudent d’ignorer ce message. (Si vous avez choisi de ne pas activer le pare-feu dans votre + cloud-config +, vous ne verrez pas de message d’erreur. Vous pouvez toujours activer le service + iptables-restore + plus tard.)

Avant de nous préoccuper du pare-feu, voyons les instances + etcd2 + sur chaque membre du cluster en conversation.

Utiliser CFSSL pour générer des certificats auto-signés

CFSSL est une boîte à outils permettant de travailler avec des certificats TLS / SSL, publiée par CloudFlare. Au moment de la rédaction de cet article, c’est l’outil choisi par les développeurs CoreOS pour la génération de certificats auto-signés, de préférence pour OpenSSL et le désormais obsolète + etcd-ca +.

Installer CFSSL sur votre ordinateur local

CFSSL nécessite une installation Go en bonne et due forme. Voir his guide d’installation de Go.

Assurez-vous que votre + $ GOPATH + est correctement défini et ajouté à votre + $ PATH +, puis utilisez + go get + pour installer les commandes + cfssl +:

export GOPATH=~/gocode
export PATH=$PATH:$GOPATH/bin
go get -u github.com/cloudflare/cfssl/cmd/cfssl
go get -u github.com/cloudflare/cfssl/...

Une autre approche consiste à récupérer les fichiers binaires pré-construits à l’adresse pkg.cfssl.org. Tout d’abord, assurez-vous que + ~ / bin + existe et se trouve dans votre chemin:

mkdir -p ~/bin
export PATH=$PATH:~/bin

Ensuite, utilisez + curl + pour récupérer les dernières versions de + cfssl + et + cfssljson + pour votre plate-forme:

curl -s -L -o ~/bin/cfssl https://pkg.cfssl.org/
curl -s -L -o ~/bin/cfssljson https://pkg.cfssl.org/

Assurez-vous que les binaires + cfssl + sont exécutables:

chmod +x ~/bin/cfssl
chmod +x ~/bin/cfssljson

Générer une autorité de certification

Maintenant que les commandes + cfssl + sont installées, nous pouvons les utiliser pour générer une autorité de certification personnalisée que nous utiliserons pour signer des certificats pour chacune de nos machines CoreOS. Commençons par créer et entrer un nouveau répertoire pour stocker ces fichiers dans:

mkdir ~/coreos_certs
cd ~/coreos_certs

Maintenant, créez et ouvrez + ca-config.json dans` + nano + `(ou votre éditeur de texte préféré):

nano ca-config.json

Collez et enregistrez ce qui suit, qui configure la manière dont + cfssl + fera la signature:

~ / coreos_certs / ca-config.json

{
   "signing": {
       "default": {
           "expiry": "43800h"
       },
       "profiles": {
           "client-server": {
               "expiry": "43800h",
               "usages": [
                   "signing",
                   "key encipherment",
                   "server auth",
                   "client auth"
               ]
           }
       }
   }
}

Il convient de noter ici les éléments + expiry +, actuellement définis à 43800 heures (ou 5 ans), et le profil + client-server +, qui inclut les utilisations + serveur auth + et + client auth +. Nous avons besoin des deux pour TLS entre homologues.

Ensuite, créez et ouvrez + ca-csr.json.

nano ca-csr.json

Collez ce qui suit en ajustant + CN + et le tableau + noms + comme vous le souhaitez pour votre emplacement et votre organisation. Vous pouvez utiliser des valeurs fictives pour l’entrée + hôtes + ainsi que pour les noms de lieu et d’organisation:

~ / coreos_certs / ca-csr.json

{
   "CN": "My Fake CA",
   "hosts": [
       "example.net",
       "www.example.net"
   ],
   "key": {
       "algo": "rsa",
       "size": 2048
   },
   "names": [
       {
           "C": "US",
           "L": "CO",
           "O": "My Company",
           "ST": "Lyons",
           "OU": "Some Org Unit"
       }
   ]
}

Avec + ca-csr.json et` + ca-config.json` en place, générez l’autorité de certification:

cfssl gencert -initca ca-csr.json | cfssljson -bare ca -

Générer et signer des certificats pour les machines CoreOS

Maintenant que nous avons une autorité de certification, nous pouvons écrire les valeurs par défaut pour une machine CoreOS:

Créez et ouvrez + coreos-1.json:

nano coreos-1.json

Collez et enregistrez ce qui suit en l’ajustant pour l’adresse IP privée de * coreos-1 * (visible dans le panneau de configuration de DigitalOcean en cliquant sur une gouttelette individuelle):

~ / coreos_certs / coreos-1.json

{
   "CN": "",
   "hosts": [
       "",
       ".local",
       "127.0.0.1",
       ""
   ],
   "key": {
       "algo": "rsa",
       "size": 2048
   },
   "names": [
       {
           "C": "",
           "L": "",
           "ST": ""
       }
   ]
}

Les parties les plus importantes sont + CN +, qui devrait être votre nom d’hôte, et le tableau + hosts +, qui doit contenir tous les éléments suivants:

  • votre nom d’hôte local

  • + 127.0.0.1 +

  • adresse IP privée de la machine CoreOS (pas son adresse IP publique)

Ceux-ci seront ajoutés au certificat obtenu sous la forme * https: //fr.wikipedia.org/wiki/SubjectAltName [subjectAltNames] *. Les connexions + etcd + (y compris au périphérique de bouclage local à + ​​127.0.0.1 +) nécessitent que le certificat ait un réseau de stockage correspondant au nom d’hôte se connectant.

Vous pouvez également modifier le tableau + noms + pour refléter votre emplacement, si vous le souhaitez. De nouveau, il est prudent d’utiliser des valeurs fictives pour les noms de lieux.

Répétez cette procédure pour chaque machine restante, en créant une correspondance + coreos-2.json + et + coreos-3.json + avec les entrées + hosts + appropriées.

A présent, pour chaque ordinateur CoreOS, générez un certificat signé et chargez-le sur l’ordinateur approprié:

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=client-server  | cfssljson -bare coreos
chmod 0644 coreos-key.pem
scp ca.pem coreos-key.pem coreos.pem core@:

Cela créera trois fichiers (+ ca.pem +, + coreos-key.pem + et + coreos.pem +), garantira que les autorisations sont correctes sur le fichier de clés et les copiera via + scp + vers *. répertoire de base de core * sur * coreos-1 *.

Répétez cette procédure pour chacune des machines restantes, en gardant à l’esprit que chaque appel de la commande écrasera le jeu précédent de fichiers de certificat:

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=client-server  | cfssljson -bare coreos
chmod 0644 coreos-key.pem
scp ca.pem coreos-key.pem coreos.pem core@:
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=client-server coreos-3.json | cfssljson -bare coreos
chmod 0644 coreos-key.pem
scp ca.pem coreos-key.pem coreos.pem core@:

Vérifiez la fonctionnalité etcd2 sur coreos-1

Avec les certificats en place, nous devrions pouvoir exécuter + fleetctl + sur * coreos-1 *. Commencez par vous connecter via SSH:

ssh -A core@

Ensuite, essayez de lister toutes les machines du cluster:

fleetctl list-machines

Vous devriez voir un identifiant pour chaque machine répertorié avec son adresse IP privée:

OutputMACHINE     IP      METADATA
7cb57440... 10.132.130.187  -
d91381d4... 10.132.87.87    -
eeb8726f... 10.132.32.222   -

Si + flottectl + se bloque indéfiniment, il peut être nécessaire de redémarrer le cluster. Sortie sur votre machine locale:

exit

Utilisez SSH pour envoyer des commandes + reboot + à chaque ordinateur CoreOS:

ssh core@coreos-1_public_ip 'sudo reboot'
ssh core@coreos-2_public_ip 'sudo reboot'
ssh core@coreos-3_public_ip 'sudo reboot'

Attendez quelques instants, reconnectez-vous à * coreos-1 * et essayez à nouveau + fleetctl +.

Configurer un pare-feu IPTables sur des membres de cluster

Avec les certificats en place, il devrait être impossible pour les autres machines du réseau local de contrôler votre cluster ou d’extraire les valeurs de + etcd2 +. Néanmoins, c’est une bonne idée de réduire la surface d’attaque disponible si possible. Afin de limiter l’exposition de notre réseau, nous pouvons ajouter quelques règles de pare-feu simples à chaque machine, en bloquant la plupart du trafic réseau local provenant de sources autres que les pairs du cluster.

N’oubliez pas que si nous activons le service + iptables-restore + dans + cloud-config +, nous verrons un message d’erreur + systemd + lors de la première connexion à une machine CoreOS:

OutputCoreOS stable (766.5.0)
Failed Units: 1
 iptables-restore.service

Cela nous permet de savoir que, même si le service est activé, le chargement de + iptables-restore + a échoué. Nous pouvons diagnostiquer cela en utilisant + systemctl +:

systemctl status -l iptables-restore
Output● iptables-restore.service - Restore iptables firewall rules
  Loaded: loaded (/usr/lib64/systemd/system/iptables-restore.service; enabled; vendor preset: disabled)
  Active: failed (Result: exit-code) since Wed 2015-11-25 00:01:24 UTC; 27min ago
 Process: 689 ExecStart=/sbin/iptables-restore /var/lib/iptables/rules-save (code=exited, status=1/FAILURE)
Main PID: 689 (code=exited, status=1/FAILURE)

Nov 25 00:01:24 coreos-2 systemd[1]: Starting Restore iptables firewall rules...
Nov 25 00:01:24 coreos-2 systemd[1]: iptables-restore.service: Main process exited, code=exited, status=1/FAILURE
Nov 25 00:01:24 coreos-2 systemd[1]: Failed to start Restore iptables firewall rules.

Nov 25 00:01:24 coreos-2 systemd[1]: iptables-restore.service: Unit entered failed state.
Nov 25 00:01:24 coreos-2 systemd[1]: iptables-restore.service: Failed with result 'exit-code'.

Il y a beaucoup d’informations ici, mais la ligne la plus utile est celle qui contient + iptables-restore [689] +, qui est le nom du processus que le système `+ systemd + 'a tenté d’exécuter avec son id de processus. C’est là que nous trouvons souvent le résultat d’erreur réel des services défaillants.

La restauration du pare-feu a échoué car, bien que nous ayons activé + iptables-restore + dans + cloud-config +, nous ne l’avons pas encore fourni avec un fichier contenant les règles souhaitées. Nous aurions pu le faire avant de créer les gouttelettes, sauf qu’il n’ya aucun moyen de savoir quelles adresses IP seront attribuées à un droplet avant sa création. Maintenant que nous connaissons chaque IP privée, nous pouvons écrire un ensemble de règles.

Ouvrez un nouveau fichier dans votre éditeur, collez ce qui suit et remplacez `, ` et ++ par l’adresse IP privée de chaque ordinateur CoreOS. Vous devrez peut-être également ajuster la section située sous + Accepter tout le trafic TCP / IP …​ + afin de refléter les services publics que vous avez l’intention d’offrir à partir du cluster, bien que cette version fonctionne bien à des fins de démonstration.

/ var / lib / iptables / rules-save

*filter
:INPUT DROP [0:0]
:FORWARD DROP [0:0]
:OUTPUT ACCEPT [0:0]

# Accept all loopback (local) traffic:
-A INPUT -i lo -j ACCEPT

# Accept all traffic on the local network from other members of
# our CoreOS cluster:
-A INPUT -i eth1 -p tcp -s  -j ACCEPT
-A INPUT -i eth1 -p tcp -s  -j ACCEPT
-A INPUT -i eth1 -p tcp -s  -j ACCEPT

# Keep existing connections (like our SSH session) alive:
-A INPUT -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT

# Accept all TCP/IP traffic to SSH, HTTP, and HTTPS ports - this should
# be customized  for your application:




# Accept pings:
-A INPUT -p icmp -m icmp --icmp-type 0 -j ACCEPT
-A INPUT -p icmp -m icmp --icmp-type 3 -j ACCEPT
-A INPUT -p icmp -m icmp --icmp-type 11 -j ACCEPT
COMMIT

Copiez ce qui précède dans votre presse-papiers, connectez-vous à * coreos-1 * et ouvrez + rules-save + en utilisant https://www.digitalocean.com/community/tutorials/installing-and-us-us-vim-text -editor-on-a-cloud-server [Vim], l’éditeur de texte par défaut sous CoreOS:

ssh -A core@
sudo vim /var/lib/iptables/rules-save

Une fois dans l’éditeur, tapez +: set paste + et appuyez sur * Entrée * pour vous assurer que l’auto-indentation est désactivée, puis appuyez sur * i * pour passer en mode insertion et collez vos règles de pare-feu. Appuyez sur * Echap * pour quitter le mode insertion et sur *: wq * pour écrire le fichier et quitter.

Enfin, assurez-vous que le fichier dispose des autorisations appropriées (lecture et écriture pour l’utilisateur, lecture seule pour le groupe et l’univers):

sudo chmod 0644 /var/lib/iptables/rules-save

Nous devrions maintenant être prêts à réessayer le service:

sudo systemctl start iptables-restore

En cas de succès, + systemctl + se fermera silencieusement. Nous pouvons vérifier l’état du pare-feu de deux manières. Tout d’abord, en utilisant + systemctl status:

sudo systemctl status -l iptables-restore

Et deuxièmement, en listant les règles + iptables + en vigueur:

sudo iptables -v -L

Nous utilisons l’option + -v + pour obtenir une sortie commentée, ce qui nous permet de savoir à quelle interface une règle donnée s’applique.

Une fois que vous êtes certain que le pare-feu de * coreos-1 * est configuré, déconnectez-vous:

exit

Ensuite, répétez cette procédure pour installer + / var / lib / iptables / rules-save + sur * coreos-2 * et * coreos-3 *.

Conclusion

Dans ce guide, nous avons défini un cluster CoreOS de base avec trois membres, fournissant à chacun un certificat TLS / SSL pour l’authentification et la sécurité du transport, et utilisé un pare-feu pour bloquer les connexions d’autres droplets sur le réseau du centre de données local. Cela permet de résoudre bon nombre des problèmes de sécurité de base liés à l’utilisation de CoreOS sur un réseau partagé.

À partir de là, vous pouvez appliquer les techniques décrites dans la suite de cette série sur la prise en main de CoreOS pour définir et gérer des services.