doc cleanup, partie ACME a terminer

acme.yaml

@@ -13,4 +13,4 @@ spec:
       http01:
         ingress:
           ingressClassName: nginx
- 
\ No newline at end of file
+  
\ No newline at end of file

atelier_secu.md

@@ -88,7 +88,7 @@ chmod +x jq
 
 - https://developer.hashicorp.com/vault/tutorials/secrets-management/pki-engine?variants=vault-deploy%3Aselfhosted
 
-#### Root CA :
+#### 1. Création du CA racine:
 
 Commandes :
 
@@ -104,40 +104,278 @@ vault write pki/config/urls issuing_certificates="$VAULT_ADDR/v1/pki/ca" \ crl_d
 → TTL de 2 semaine ( pour tester le bridge CA )
 → Rôle permissif au niveau des noms (a changer ?)
     
-#### Intermediate CA :
+#### 2. Création du CA intermédiaire :
 
 Commandes :
 
 ```
 vault secrets enable -path=pki_int pki
 vault secrets tune -max-lease-ttl=240h pki_int
+vault write -format=json pki_int/intermediate/generate/internal \
+     common_name="chepia.ch Intermediate Authority" \
+     issuer_name="chepia-dot-ch-intermediate" \
+     | jq -r '.data.csr' > pki_intermediate.csr
+vault write -format=json pki/root/sign-intermediate \
+     issuer_ref="root" \
+     csr=@pki_intermediate.csr \
+     format=pem_bundle ttl="240h" \
+     | jq -r '.data.certificate' > intermediate.cert.pem
+vault write pki_int/intermediate/set-signed certificate=@intermediate.cert.pem
 ```
 
 → TTL 10 jours
 
-- **ADD GUI STEPS**
 
+#### 3. Création du rôle :
 
-#### Create a role :
+- Un rôle définit une politique d'accès au certificats intermédiaire : Le domaine doit être `chepia.ch` ou un sous domaine comme `www.chepia.ch`, et le temps de vie maximum est de 120 heures.
 
-- **ADD GUI STEPS**
+Commandes :
+
+```
+ vault write pki_int/roles/chepia-dot-ch \
+     issuer_ref="$(vault read -field=default pki_int/config/issuers)" \
+     allowed_domains="chepia.ch" \
+     allow_subdomains=true \
+     max_ttl="120h"
+```
 
 
-#### Request certificates
+#### 4. Demander un certificat :
+
+Commande :
+
+```
+vault write pki_int/issue/chepia-dot-ch common_name="test.chepia.ch" ttl="24h"
+```
 
-- **ADD GUI STEPS**
+→ Crée un certificat valide 24 heures pour le nom de domaine "test.chepia.ch"
 
 ### Configurer cert-manager
 
 - https://developer.hashicorp.com/vault/tutorials/kubernetes/kubernetes-cert-manager
 
-### Delete expired certs
+#### 1. Activation de cert-manager :
+    
+- `microk8s enable cert-manager`
+
+#### 2. Configurer l'accès entre Vault et Kubernetes
+
+```bash
+kubectl exec --stdin=true --tty=true vault-0 -- /bin/sh
+vault auth enable kubernetes
+write auth/kubernetes/config \
+        kubernetes_host="https://$KUBERNETES_PORT_443_TCP_ADDR:443"
+```
+
+→ La variable globale `$KUBERNETES_PORT_443_TCP_ADDR`est à modifier selon votre configuration. L'adresse utilisée par le service principal de Kubernetes peut être consultée avec la commande `microk8s kubectl get services | grep kubernetes`. Dans mon cas, Kubernetes utilise l'adresse 10.152.183.1. 
+
+#### 3. Configurer l'émetteur de certificats
+1. Créer une identité pour communiquer avec l'émetteur. C'est avec cette identité que cert-manager utilisera pour accéder au rôle créé à l'étape précédente : \newline
+ `kubectl create serviceaccount issuer`
+2. Créer un secret que l'identité `issuer` utilisera pour s'authentifier :
+
+- On crée pour cela le fichier `issuer-secret.yaml`:
+
+``` 
+apiVersion: v1
+kind: Secret
+metadata:
+  name: issuer-token-lmzpj
+  annotations:
+    kubernetes.io/service-account.name: issuer
+type: kubernetes.io/service-account-token
+```
+
+- Appliquer la config avec la commande `microk8s kubectl apply -f issuer-secret.yaml`.
+
+3. Créer le ficher de configuration de l'émetteur `vault-issuer.yaml`:
+
+```yaml
+apiVersion: cert-manager.io/v1
+kind: Issuer
+metadata:
+  name: vault-issuer
+  namespace: default
+spec:
+  vault:
+    server: http://vault.default:8200
+    path: pki_int/sign/chepia-dot-ch
+    auth:
+      kubernetes:
+        mountPath: /v1/auth/kubernetes
+        role: issuer
+        secretRef:
+          name: issuer-token-lmzpj
+          key: token
+```
+
+- Appliquer la config avec la commande `microk8s kubectl apply -f vault-issuer.yaml`.
+
+
+
+### Mise en place de TLS sur un service
+
+#### 1. Création du service
+
+- Nous allons utiliser un simple serveur web Nginx pour représenter la page d'accueil  de notre entreprise :
+
+1. Créer le fichier de config de la page d'accueil :
+
+```yaml
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: nginx-configmap
+  namespace: default
+data:
+  index.html: |
+    <html>
+    <h1> Bienvenue sur l'intranet de CHEPIA </h1>
+    <h3> Certificats gratos !! </h3>
+    </html>
+```
+
+2. Créer le fichier de config du serveur :
+
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: nginx
+  labels:
+  app: nginx
+spec:
+  selector:
+    matchLabels:
+      app: nginx
+  template:
+    metadata:
+      labels:
+        app: nginx
+    spec:
+      containers:
+      - name: nginx
+        image: nginx:latest
+        ports:
+        - containerPort: 80
+        volumeMounts:
+        - name: nginx-index
+          mountPath: /usr/share/nginx/index.html
+          subPath: index.html
+      volumes:
+      - name: nginx-index
+        configMap:
+          name: nginx-configmap
+```
+
+3. Appliquer les configs :  `microk8s kubectl apply -f nginx-configmap.yaml`, `microk8s kubectl apply -f nginx.yaml`
+
+
+#### 2. Création du certificat du service :
+
+- Création du fichier `cert.yaml` :
+
+```yaml
+apiVersion: cert-manager.io/v1 
+kind: Certificate 
+metadata:
+  name: chepia-cert
+  namespace: default 
+spec:
+  issuerRef:
+    name: vault-issuer
+  commonName: www.chepia.ch
+  secretName: chepia-cert 
+  dnsNames:
+  - www.chepia.ch
+```
+
+- Appliquer la config avec la commande `microk8s kubectl apply -f cert.yaml`
+
+#### 3. Configuration de l'accès au service
+
+- Créer le fichier `nginx-service.yaml`:
+
+```yaml
+apiVersion: v1
+kind: Service
+metadata:
+  name: nginx
+spec:
+  ports:
+  - port: 80
+    targetPort: 80
+    protocol: TCP
+  selector:
+    app: nginx
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: nginx
+spec:
+  ingressClassName: nginx
+  tls:
+  - hosts:
+    - www.chepia.ch
+    secretName: chepia-cert
+  rules:
+  - host: www.chepia.ch 
+    http:
+      paths:
+      - path: /
+        pathType: Prefix
+        backend:
+          service:
+            name: nginx
+            port:
+              number: 80
+```
+
+- Appliquer la config avec la commande `microk8s kubectl apply -f nginx-service.yaml`
+
+#### 4. Test de l'accès au service
+
+Pour pouvoir accéder à notre service de manière sécurisée, il faut le faire par son nom de domaine, car c'est à celui-ci qu'est relié le certificat créé précédemment. Pour cela, on va ajouter la ligne suivante au fichier `/etc/hosts`:
+`127.0.0.1 www.chepia.ch`
+
+Ensuite, on peut tester la connexion TLS avec la commande : 
+` curl -kivL   'https://www.chepia.ch'`
+
+![Connexion à notre service en https avec curl. ](images/curl.png "Connexion à notre service en https avec curl. ")
+
+On peut voir que le certificat du serveur est bien émit par notre autorité de certification intermédiaire. Par contre 
+la ligne `SSL certificate verify result: unable to get local issuer certificate (20), continuing anyway.` indique que notre CA n'a pas été reconnu. C'est normal, car on a pas encore ajouté le certificat racine de notre autorité à la liste des CA reconnu par notre système d'exploitation. Si on essaye d'accéder à notre service avec un navigateur web, on va rencontrer l'avertissement suivant :
+
+![Notre CA n'est pas reconnu par le navigateur Firefox](images/auth_unknown.png "Notre CA n'est pas reconnu par le navigateur Firefox")
+
+Pour remédier à cela, on va chercher le certificat de notre autorité intermédiaire dans l'interface graphique de Vault. 
+
+![On peut télécharger ou copier le certificat depuis la page secrets -> pki_int -> issuers -> chepia.ch](images/cert_gui.png "On peut télécharger ou copier le certificat depuis la page secrets -> pki_int -> issuers -> chepia.ch Intermediate Authority")
+
+Ensuite, on crée un sous-répertoire `chepia.ch` dans le répertoire `/usr/local/share/ca-certificates`:
+`sudo mkdir /usr/local/share/ca-certificates/chepia.ch`
+On place le certificat dans le répertoire et on met à jour la liste des CAs reconnus avec `sudo update-ca-certificates`.
+
+Il faut aussi ajouter le certificat à la liste des CAs de confiance de votre navigateur. Pour cela, allez dans *préférences*, *Vie privée et sécurité*, *Certificats* et cliquer sur *Afficher les certificats* puis *Importer*.
+Une fois le certificat importé, on retrouve notre autorité dans la liste des CAs de confiance.
+
+![Liste des CAs de confiance dans Firefox](images/chrome_certs.png "Liste des CAs de confiance dans Firefox")
+
+Si on retourne sur *www.chepia.ch*, l'alerte a disparu.
+
+![Le point d'exclamation a disparu du cadenas](images/lock.png "Le point d'exclamation a disparu du cadenas")
+
+### Mise à jour des certificats
+
+#### 1. Suppression des certificats expirés
 
 ```
 vault write pki_int/tidy tidy_cert_store=true tidy_revoked_certs=true
 ```
 
-### Root certificate rotation
+#### 2. Rotation du certificat racine
 
 ```
     vault write pki/root/rotate/internal \
@@ -150,7 +388,9 @@ vault write pki/roles/chepia-servers allow_any_name=true
 ```
 
 
-#### Root bridge
+#### 3. Création d'un pont entre le nouveau certificat racine et l'ancien
+
+Cette étape permet aux services qui n'ont pas communiqué avec le CA depuis longtemps et doivent mettre à jour leur certificat racine. Le pont permet à ses service de faire confiance à notre nouveau certificat racine.
 
 ```
     cd vault
@@ -172,13 +412,13 @@ vault write pki/roles/chepia-servers allow_any_name=true
           
 ```
 
-#### Set default issuer
+#### 4. Remplacer l'émetteur par défaut 
 
 ```
 vault write pki/root/replace default=root-2
 ```
 
-### cross-sign intermediate 
+#### 5.  Signer l'autorité intermédiaire avec notre nouveau certificat racine
 
 ```bash
 cd vault
@@ -272,59 +512,6 @@ spec:
 \- www.chepia.ch
 ```
 
-### Expose https service
 
-- Nous allons utiliser un simple serveur web Nginx pour représenter la page d'accueil de l'intranet de notre entreprise :
-
-1. Créer le fichier de config de la page d'accueil :
-
-```yaml
-apiVersion: v1
-kind: ConfigMap
-metadata:
- name: nginx-configmap
- namespace: default
-data:
- index.html: |
-    <html>
-    <h1> Bienvenue sur l'intranet de CHEPIA </h1>
-    <h3> Certificats gratos !! </h3>
-    </html>
-```
-
-2. Créer le fichier de config du serveur :
-
-```yaml
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: nginx-configmap
-  labels:
-  app: nginx
-spec:
- selector:
-   matchLabels:
-     app: nginx
- template:
-   metadata:
-     labels:
-       app: nginx
-   spec:
-     containers:
-     - name: nginx
-     image: nginx:latest
-     ports:
-     - containerPort: 80
-     volumeMounts:
-     - name: nginx-index
-       mountPath: /usr/share/nginx/index.html
-       subPath: index.html
-     volumes:
-     - name: nginx-index
-       configMap:
-         name: nginx-configmap
-```
-
-3. Appliquer les configs :  `microk8s kubectl apply -f nginx-configmap.yaml`, `microk8s kubectl apply -f nginx.yaml`
 
 https://cert-manager.io/docs/usage/ingress/
\ No newline at end of file

cert.yaml

@@ -5,8 +5,8 @@ metadata:
   namespace: default  
 spec:  
   issuerRef:  
-    name: chepia-ch  
-    kind: ClusterIssuer  
+    name: vault-issuer
+  commonName: www.chepia.ch
   secretName: chepia-cert 
   dnsNames:  
     - www.chepia.ch
\ No newline at end of file

nginx-service.yaml

@@ -4,7 +4,7 @@ metadata:
   name: nginx
 spec:
   ports:
-  - port: 443
+  - port: 80
     targetPort: 80
     protocol: TCP
   selector:
@@ -14,16 +14,15 @@ apiVersion: networking.k8s.io/v1
 kind: Ingress
 metadata:
   name: nginx
-  annotations: 
-    cert-manager.io/cluster-issuer: chepia-ch
 spec:
   ingressClassName: nginx
   tls:
   - hosts:
-    - chepia.ch
-    secretName: tls-secret
+    - www.chepia.ch
+    secretName: chepia-cert
   rules:  
-  - http:
+  - host: www.chepia.ch 
+    http:
       paths:
       - path: /
         pathType: Prefix