Note :

Ce tutoriel nécessite l'accès à Oracle Cloud. Pour vous inscrire à un compte gratuit, voir Introduction à l' niveau gratuit d'Oracle Cloud Infrastructure.
Il utilise des exemples de valeurs pour les données d'identification, la location et les compartiments Oracle Cloud Infrastructure. À la fin de votre laboratoire, remplacez ces valeurs par celles propres à votre environnement en nuage.

Tirer parti de la tunnelisation SSH avec Oracle Cloud Infrastructure Kubernetes Engine pour sécuriser le développement d'applications

Présentation

Quand j'ai eu SSH tunneling avec OKE travaillant avec l'aide d'Ali Mukadam, je l'ai appelé "magique".

Il m'a répondu par le message suivant :

Vous l'avez appelé magie, d'autres l'appellent science. Là où je suis, ils sont un et le même."

La citation originale provient d'un film de Thor :

Vos ancêtres l'ont appelé magique, mais vous l'appelez science. Je viens d'un pays où ils sont un et le même."

Qu'est-ce que cette magie?

Dans le développement d'applications modernes, il est essentiel de sécuriser les connexions entre les ressources locales et en nuage, en particulier lors de l'utilisation d'Oracle Cloud Infrastructure Kubernetes Engine (OCI Kubernetes Engine ou OKE). La tunnelisation SSH offre un moyen simple mais puissant de se connecter en toute sécurité aux grappes OKE, permettant aux développeurs de gérer et d'interagir avec les ressources sans les exposer au réseau Internet public. Ce tutoriel explique comment configurer la tunnelisation SSH avec OKE et comment les développeurs peuvent intégrer cette approche dans leur flux de travail pour améliorer la sécurité et l'efficacité. De la configuration initiale aux meilleures pratiques, nous couvrons tout ce dont vous avez besoin pour exploiter efficacement la tunnelisation SSH dans vos applications basées sur OKE.

L'image suivante illustre les flux de trafic complets de SSH tunnelisant deux applications différentes.

Objectifs

Tirez parti de la tunnelisation SSH avec OKE pour un développement d'application sécurisé.

Tâche 1 : Déployer une grappe Kubernetes sur OKE (avec un hôte bastion et une instance d'opérateur)

Assurez-vous d'avoir une grappe Kubernetes déployée sur OKE.

Pour déployer une grappe Kubernetes sur OKE, utilisez l'une des méthodes suivantes :
- Déployer une grappe Kubernetes avec Terraform à l'aide d'Oracle Cloud Infrastructure Kubernetes Engine : Déployer une seule grappe Kubernetes sur OKE à l'aide de Terraform.
- Utiliser Terraform pour déployer plusieurs grappes Kubernetes sur différentes régions OCI à l'aide d'OKE et créer un réseau maillé complet à l'aide de RPC : Déployez plusieurs grappes Kubernetes sur plusieurs régions d'OKE à l'aide de Terraform.
- Tâche 1 : Créer une nouvelle grappe Kubernetes et vérifier les composants : Déployer une grappe Kubernetes sur OKE à l'aide du mode de création rapide.
- Tâche 1 : Déployer une grappe Kubernetes à l'aide d'OKE : Déployer une grappe Kubernetes sur OKE à l'aide du mode de création personnalisée.
Dans ce tutoriel, nous utiliserons Déployer une grappe Kubernetes avec Terraform à l'aide d'Oracle Cloud Infrastructure Kubernetes Engine en tant que grappe Kubernetes de base sur OKE pour expliquer comment utiliser un tunnel SSH pour accéder à une application basée sur un conteneur déployée sur OKE avec localhost.

Examinons rapidement l'environnement OKE OCI pour définir l'étape.
Réseau en nuage virtuel (VCN)

Connectez-vous à la console OCI, naviguez jusqu'à Réseau et Réseaux en nuage virtuels.
- Vérifiez le VCN nommé oke.
- Cliquez sur le VCN oke.
Sous-réseaux

Allez à la page Détails du VCN.
1. Cliquez sur sous-réseaux.
2. Vérifiez les sous-réseaux déployés.
Passerelles

Allez à la page Détails du VCN.
1. Cliquez sur Passerelles Internet.
2. Vérifiez la passerelle Internet créée.
1. Cliquez sur Passerelles NAT.
2. Vérifiez la passerelle NAT créée.
1. Cliquez sur Passerelles de service.
2. Vérifiez la passerelle de service créée.
1. Cliquez sur Listes de sécurité.
2. Sert à consulter les listes de sécurité créées.
Groupes de noeuds

Naviguez jusqu'à Services de développement et Conteneur et artefacts.
1. Cliquez sur Grappes Kubernetes (OKE).
2. Cliquez sur la grappe oke.
1. Cliquez sur Groupes de noeuds.
2. Vérifiez les groupes de noeuds.
Instances

Naviguez jusqu'à Calcul et Instances.
1. Cliquez sur Instances.
2. Vérifiez les déploiements des noeuds de travail Kubernetes.
3. Vérifiez le déploiement de l'hôte bastion.
4. Vérifiez le déploiement de l'opérateur Kubernetes.
L'image suivante illustre un aperçu complet de ce que sera notre point de départ pour le contenu restant de ce tutoriel.
L'image suivante illustre une vue simplifiée de la figure précédente. Nous utiliserons cette figure dans le reste de ce tutoriel.

Tâche 2 : Déployer un serveur Web NGINX sur la grappe Kubernetes

L'opérateur n'est pas directement accessible à partir d'Internet et nous devons passer par l'hôte bastion.

Dans ce tutoriel, nous utilisons un script SSH fourni par Ali Mukadam pour nous connecter à l'opérateur à l'aide d'une seule commande SSH. Ce script et cette méthode de connexion sont fournis ici : Tâche 4 : Utiliser l'hôte bastion et l'opérateur pour vérifier la connectivité. Vous aurez besoin de ce script plus tard dans ce tutoriel, alors assurez-vous de l'utiliser.
- Configurez une session SSH pour l'opérateur Kubernetes.
- Vérifiez les noeuds de travail actifs à l'aide de la commande kubectl get nodes.
- Vérifiez tous les noeuds de travail actifs.

Pour créer un exemple d'application NGINX qui s'exécute dans un conteneur, créez un fichier YAML nommé modified2_nginx_ext_lb.yaml avec le code suivant sur l'opérateur.

Le fichier YAML contient le code permettant de créer l'application de serveur Web NGINX avec 3 répliques et créera également un service de type équilibreur de charge.

modified2_nginx_ext_lb.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
  app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
  - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: my-nginx-svc
  labels:
    app: nginx
  annotations:
    oci.oraclecloud.com/load-balancer-type: "lb"
    service.beta.kubernetes.io/oci-load-balancer-internal: "true"
    service.beta.kubernetes.io/oci-load-balancer-subnet1: "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaaguwakvc6jxxxxxxxxxxxxxxxxxxxu7rixvdf5urvpxldhya"
    service.beta.kubernetes.io/oci-load-balancer-shape: "flexible"
    service.beta.kubernetes.io/oci-load-balancer-shape-flex-min: "50"
    service.beta.kubernetes.io/oci-load-balancer-shape-flex-max: "100"
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: nginx

Nous voulons rendre cette application accessible en interne et décider de créer le service de type équilibreur de charge attaché au sous-réseau d'équilibreur de charge privé.

Pour affecter le service de type équilibreur de charge à un sous-réseau d'équilibreur de charge privé, vous avez besoin de l'OCID du sous-réseau d'équilibreur de charge privé et vous devez ajouter le code suivant dans la section annotations.

annotations:
  oci.oraclecloud.com/load-balancer-type: "lb"
  service.beta.kubernetes.io/oci-load-balancer-internal: "true"
  service.beta.kubernetes.io/oci-load-balancer-subnet1: "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaaguwakvcxxxxxxxxxxxxxxxxxxxxxxxxxxxxixvdf5urvpxldhya"
  service.beta.kubernetes.io/oci-load-balancer-shape: "flexible"
  service.beta.kubernetes.io/oci-load-balancer-shape-flex-min: "50"
  service.beta.kubernetes.io/oci-load-balancer-shape-flex-max: "100"

Pour obtenir l'OCID du sous-réseau de l'équilibreur de charge privé, cliquez sur le sous-réseau interne.

Cliquez sur Afficher et sur Copier pour obtenir l'OCID du sous-réseau d'équilibreur de charge privé complet. Utilisez cet OCID dans la section annotations.
Pour déployer l'application NGINX et le service de type équilibreur de charge, exécutez les commandes suivantes :
1. Pour créer le fichier YAML sur l'opérateur.
```
nano modified2_nginx_ext_lb.yaml
```
2. Pour déployer l'application NGINX avec le service de type équilibreur de charge.
```
kubectl apply -f modified2_nginx_ext_lb.yaml
```
  Pour vérifier si l'application NGINX a été déployée avec succès (non affichée dans l'image).
```
kubectl get pods
```
3. Pour vérifier si le service de type équilibreur de charge a été déployé.
```
kubectl get svc
```
4. Notez que le service de type équilibreur de charge a été déployé.
Lorsque nous examinons le sous-réseau d'équilibreur de charge interne, nous pouvons voir que le bloc CIDR de ce sous-réseau est 10.0.2.0/27. Le nouveau service de l'équilibreur de charge a l'adresse IP 10.0.2.3.
Pour vérifier l'objet d'équilibreur de charge dans la console OCI, naviguez jusqu'à Réseau, Équilibreur de charge et cliquez sur Équilibreur de charge.
L'image suivante illustre le déploiement que nous avons effectué jusqu'à présent. Notez que l'équilibreur de charge a été ajouté.

Tester le nouveau pod/application

Approche 1 : À partir d'un pod temporaire

Pour tester si l'application NGINX nouvellement déployée fonctionne avec le service de type équilibreur de charge, nous pouvons effectuer un test de connectivité interne à l'aide d'un pod temporaire.

Il existe plusieurs façons de tester la connectivité à l'application, une façon serait d'ouvrir un navigateur et de tester si vous pouvez accéder à la page Web. Mais lorsque nous n'avons pas de navigateur disponible, nous pouvons effectuer un autre test rapide en déployant un pod temporaire.

Pour créer un pod temporaire et l'utiliser pour les tests de connectivité, voir Tâche 3 : Déployer un exemple d'application Web et de service.
- Exécutez la commande suivante :
  1. Pour obtenir l'adresse IP du service d'équilibreur de charge interne.
    kubectl get svc
  2. Pour déployer un exemple de pod afin de tester la connectivité de l'application Web.
    kubectl run --rm -i -t --image=alpine test-$RANDOM -- sh
  3. Pour tester la connectivité au serveur Web à l'aide de wget.
    wget -qO- http://<ip-of-internal-lb-service>
  4. Notez le code HTML renvoyé par le serveur Web, confirmant le fonctionnement du serveur Web et de la connectivité à l'aide du service d'équilibrage de charge interne.
- Exécutez la commande suivante pour quitter le pod temporaire.
```
exit
```
  Notez que le pod est supprimé immédiatement après la fermeture de l'interface de ligne de commande.
- L'image suivante illustre le déploiement que nous avons effectué jusqu'à présent. Notez que le pod déployé temporairement se connecte au service de type IP d'équilibreur de charge pour tester la connectivité.
Approche 2 : De votre ordinateur local
- Exécutez la commande suivante pour tester la connectivité à l'application de test NGINX avec le service de type équilibreur de charge à partir de notre ordinateur portable local.
```
iwhooge@iwhooge-mac ~ % wget -qO- <ip-of-internal-lb-service>
```
  Comme vous le remarquerez, cela ne fonctionne pas actuellement car le service de type équilibreur de charge a une adresse IP interne qui n'est accessible que dans l'environnement Kubernetes.
- Exécutez la commande suivante pour essayer d'accéder à l'application NGINX à l'aide de l'adresse IP locale avec un port personnalisé 8080.
```
iwhooge@iwhooge-mac ~ % wget -qO- 127.0.0.1:8080
iwhooge@iwhooge-mac ~ %
```
  Pour l'instant, cela ne fonctionne pas, mais nous utiliserons la même commande plus loin dans ce tutoriel après avoir configuré le tunnel SSH.
L'image suivante illustre le déploiement que nous avons effectué jusqu'à présent. Notez que la connexion tunneled à l'adresse IP locale ne fonctionne pas.

Tâche 3 : Créer un script de configuration SSH avec des entrées Localhost

Pour permettre au tunnel SSH de fonctionner, nous devons ajouter l'entrée suivante dans notre fichier de configuration SSH situé dans le dossier /Users/iwhooge/.ssh.

Exécutez la commande nano /Users/iwhooge/.ssh/config pour modifier le fichier de configuration.
Ajoutez la ligne suivante dans la section Hôte operator47.
```
LocalForward 8080 127.0.0.1:8080
```

Sortie du fichier de configuration SSH.

iwhooge@iwhooge-mac .ssh % pwd
/Users/iwhooge/.ssh

iwhooge@iwhooge-mac .ssh % more config
Host bastion47
    HostName 129.xxx.xxx.xxx
    user opc
    IdentityFile ~/.ssh/id_rsa
    UserKnownHostsFile /dev/null
    StrictHostKeyChecking=no
    TCPKeepAlive=yes
    ServerAliveInterval=50

Host operator47
    HostName 10.0.0.11
    user opc
    IdentityFile ~/.ssh/id_rsa
    ProxyJump bastion47
    UserKnownHostsFile /dev/null
    StrictHostKeyChecking=no
    TCPKeepAlive=yes
    ServerAliveInterval=50
    LocalForward 8080 127.0.0.1:8080
iwhooge@iwhooge-mac .ssh %

Notez que la commande LocalForward est ajoutée au fichier de configuration SSH.

Tâche 4 : Configurer le tunnel SSH et se connecter au serveur Web NGINX à l'aide de Localhost

Si vous êtes connecté avec SSH à l'opérateur, déconnectez-vous de cette session.
1. Reconnectez-vous à l'opérateur à l'aide du script.
```
iwhooge@iwhooge-mac ~ % ssh operator47
```
2. Exécutez la commande suivante pour obtenir l'adresse IP du service d'équilibreur de charge interne.
```
[opc@o-sqrtga ~]$ kubectl get svc
```
3. Exécutez la commande suivante sur l'opérateur (fenêtre SSH) pour configurer le tunnel SSH et transmettre tout le trafic qui va à localhost 8080 au service de type équilibreur de charge 80. Le service de type équilibreur de charge transmet ensuite le trafic éventuellement à l'application NGINX.
```
[opc@o-sqrtga ~]$ k port-forward svc/my-nginx-svc 8080:80
```
  Notez les messages de transfert dans la fenêtre SSH que le port localhost 8080 est transféré vers le port 80.
```
Forwarding from 127.0.0.1:8080 -> 80
Forwarding from [::1]:8080 -> 80
```
Testez la connectivité à partir de votre ordinateur local et vérifiez si la connectivité fonctionne à l'aide d'une adresse IP locale (127.0.0.1) avec le port 8080 et vérifiez si cela vous permettra de vous connecter à l'application NGINX dans l'environnement OKE.
Ouvrez un nouveau terminal et exécutez la commande suivante pour tester la connectivité.
```
iwhooge@iwhooge-mac ~ % wget -qO- 127.0.0.1:8080
```

Notez que vous obtiendrez la sortie suivante dans le terminal de votre ordinateur local, ce qui signifie qu'il fonctionne.

iwhooge@iwhooge-mac ~ % wget -qO- 127.0.0.1:8080
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>
iwhooge@iwhooge-mac ~ %

Dans la fenêtre SSH de l'opérateur, notez que la sortie a changé et qu'une nouvelle ligne a ajouté Traitement de la connexion pour 8080.
Un test rapide à l'aide d'un navigateur Web affiche la sortie suivante.
L'image suivante illustre le déploiement que nous avons effectué jusqu'à présent. Notez que la connexion canalisée à l'adresse IP locale fonctionne.

Tâche 5 : Déployer un service MySQL Database sur la grappe Kubernetes

Nous pouvons atteindre l'application NGINX au moyen du tunnel SSH. Ajoutez maintenant un service de base de données MySQL qui s'exécute dans l'environnement OKE.

Pour configurer un service de base de données MySQL dans un environnement Kubernetes, vous devez créer :
- Clé secrète pour la protection du mot de passe.
- Un volume persistant et une revendication de volume persistant pour le stockage de base de données.
- Service de base de données MYSQL avec service de type équilibreur de charge.

Exécutez les commandes suivantes :

Créez le mot de passe pour le service de base de données MySQL.

nano mysql-secret.yaml

Copiez le code YAML suivant dans mysql-secret.yaml.

apiVersion: v1
kind: Secret
metadata:
  name: mysql-secret
type: kubernetes.io/basic-auth
stringData:
  password: Or@cle1

Appliquez le code YAML.
```
kubectl apply -f mysql-secret.yaml
```

Créez le stockage pour le service de base de données MySQL.

nano mysql-storage.yaml

Copiez le code YAML suivant dans mysql-storage.yaml.

apiVersion: v1
kind: PersistentVolume
metadata:
  name: mysql-pv-volume
  labels:
    type: local
spec:
  storageClassName: manual
  capacity:
    storage: 20Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pv-claim
spec:
  storageClassName: manual
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 20Gi

Appliquez le code YAML.
```
kubectl apply -f mysql-storage.yaml
```

Créez le service de base de données MySQL et le service de type équilibreur de charge.

nano mysql-deployment.yaml

Copiez le code YAML suivant dans mysql-deployment.yaml.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mysql
spec:
  selector:
    matchLabels:
      app: mysql
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
      - image: mysql:latest
        name: mysql
        env:
        - name: MYSQL_ROOT_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-secret
              key: password
        ports:
        - containerPort: 3306
          name: mysql
        volumeMounts:
        - name: mysql-persistent-storage
          mountPath: /var/lib/mysql
      volumes:
      - name: mysql-persistent-storage
        persistentVolumeClaim:
          claimName: mysql-pv-claim
---
apiVersion: v1
kind: Service
metadata:
  name: my-mysql-svc
  labels:
    app: mysql
  annotations:
    oci.oraclecloud.com/load-balancer-type: "lb"
    service.beta.kubernetes.io/oci-load-balancer-internal: "true"
    service.beta.kubernetes.io/oci-load-balancer-subnet1: "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaaguwakvc6xxxxxxxxxxxxxxxxxxxxxx2rseu7rixvdf5urvpxldhya"
    service.beta.kubernetes.io/oci-load-balancer-shape: "flexible"
    service.beta.kubernetes.io/oci-load-balancer-shape-flex-min: "50"
    service.beta.kubernetes.io/oci-load-balancer-shape-flex-max: "100"
spec:
  type: LoadBalancer
  ports:
  - port: 3306
  selector:
    app: mysql

Appliquez le code YAML.
```
kubectl apply -f mysql-deployment.yaml
```
Vérifiez si le service de base de données MySQL a été déployé.
```
kubectl get pod
```
Notez que le service de base de données MySQL a été déployé.
Vérifiez si le service de type équilibreur de charge a été déployé.
```
kubectl get svc
```
Notez que le service de type équilibreur de charge a été déployé.

Pour vérifier l'objet d'équilibreur de charge dans la console OCI, naviguez jusqu'à Réseau, Équilibreur de charge et cliquez sur l'équilibreur de charge.
Pour accéder à la console de terminal du service de base de données MySQL, nous pouvons utiliser la commande kubectl exec et la commande de tunnel SSH localhost.
1. Exécutez la commande suivante pour accéder à la console de terminal à partir de l'opérateur.
```
kubectl exec --stdin --tty mysql-74f8bf98c5-bl8vv -- /bin/bash
```
2. Exécutez la commande suivante pour accéder à la console du service de base de données MySQL.
```
mysql -p
```
3. Entrez le mot de passe que vous avez spécifié dans le fichier mysql-secret.yaml et notez le message de bienvenue du service de base de données MySQL.
4. Exécutez l'interrogation SQL suivante pour voir la liste de toutes les bases de données MySQL dans le service de base de données.
```
SHOW DATABASES;
```
Accédez maintenant à la console de gestion du service de base de données MySQL à partir de l'environnement Kubernetes.
L'image suivante illustre le déploiement que nous avons effectué jusqu'à présent. Notez que le service MySQL avec le service de type équilibreur de charge est déployé.

Tâche 6 : Ajouter des entrées Localhost supplémentaires dans le script de configuration SSH

Ajoutez des entrées localeshost supplémentaires dans le script de configuration SSH pour accéder au nouveau service de base de données MySQL.

Pour permettre au tunnel SSH de fonctionner pour le service de base de données MySQL, nous devons ajouter l'entrée suivante dans notre fichier de configuration SSH situé dans le dossier /Users/iwhooge/.ssh.
Exécutez la commande nano /Users/iwhooge/.ssh/config pour modifier le fichier de configuration.
Ajoutez la ligne suivante dans la section Hôte operator47.
```
LocalForward 8306 127.0.0.1:8306
```

Sortie du fichier de configuration SSH.

Host bastion47
    HostName 129.xxx.xxx.xxx
    user opc
    IdentityFile ~/.ssh/id_rsa
    UserKnownHostsFile /dev/null
    StrictHostKeyChecking=no
    TCPKeepAlive=yes
    ServerAliveInterval=50
Host operator47
    HostName 10.0.0.11
    user opc
    IdentityFile ~/.ssh/id_rsa
    ProxyJump bastion47
    UserKnownHostsFile /dev/null
    StrictHostKeyChecking=no
    TCPKeepAlive=yes
    ServerAliveInterval=50
    LocalForward 8080 127.0.0.1:8080
    LocalForward 8306 127.0.0.1:8306

Notez que la commande LocalForward est ajoutée au fichier de configuration SSH.

Tâche 7 : Configurer le tunnel SSH et se connecter à MySQL Database à l'aide de Localhost

Pour tester la connexion au service de base de données MySQL à partir de l'ordinateur local, vous devez télécharger et installer MySQL Workbench sur l'ordinateur local.
1. Ouvrez à nouveau un nouveau terminal à l'opérateur à l'aide du script. Laissez l'autre terminal ouvert.
```
iwhooge@iwhooge-mac ~ % ssh operator47
```
2. Exécutez la commande suivante dans la fenêtre SSH de l'opérateur pour configurer le tunnel SSH et transférer tout le trafic qui va vers localhost 8306 vers le service de type équilibreur de charge 3306. Le service de type équilibreur de charge transmettra ensuite le trafic éventuellement au service de base de données MySQL.
```
[opc@o-sqrtga ~]$ k port-forward svc/my-mysql-svc 8306:3306
```
3. Notez les messages de transfert dans la fenêtre SSH que le port localhost 8306 est transféré vers le port 3306.
```
Forwarding from 127.0.0.1:8306 -> 3306
Forwarding from [::1]:8306 -> 3306
```
L'application MySQL Workbench est installée et la session et le tunnel SSH sont établis. Ouvrez l'application MySQL Workbench sur votre ordinateur local.
Cliquez sur + pour ajouter une connexion MySQL.
Dans Configurer une nouvelle connexion, entrez les informations suivantes.
1. Nom de la connexion : Entrez un nom.
2. Nom d'hôte : Entrez l'adresse IP 127.0.0.1 (localhost tel que nous tunnelisons le trafic).
3. Port : Entrez le port à 8306, le port que nous utilisons pour la transmission du tunnel local pour le service de base de données MySQL.
4. Cliquez sur Tester la connexion.
1. Mot de passe : Entrez le mot de passe que vous avez spécifié dans le fichier mysql-secret.yaml.
2. Cliquez sur OK.
Cliquez sur Continuer quand même pour ignorer l'avertissement de connexion. Cet avertissement est donné en tant que version de l'application MySQL Workbench et la version du service de base de données MySQL déployée peut ne pas être compatible.
1. Notez le message de connexion réussie.
2. Cliquez sur OK.
3. Cliquez sur OK pour enregistrer la connexion MySQL.
Cliquez sur la connexion MySQL enregistrée pour ouvrir la session.
Notez le message Veuillez patienter....
Cliquez sur Continuer quand même pour ignorer l'avertissement de connexion.
1. Exécutez l'interrogation SQL suivante pour définir une liste de toutes les bases de données MySQL dans le service de base de données.
```
SHOW DATABASES;
```
2. Cliquez sur l'icône de foudre.
3. Notez la sortie de toutes les bases de données MySQL dans le service de base de données MySQL.
Dans la fenêtre SSH de l'opérateur, notez que la sortie a changé et qu'une nouvelle ligne a ajouté Traitement de la connexion pour 8306.
Il y a plusieurs entrées parce que nous avons établi plusieurs connexions, chacune pour :
- Tester.
- Connexion réelle.
- Interrogation SQL.
- Test que nous avons fait plus tôt (supplémentaire).
Nous pouvons maintenant ouvrir plusieurs sessions SSH vers l'opérateur et exécuter plusieurs commandes de tunnel pour différentes applications simultanément. Notez les fenêtres suivantes.
1. Terminal SSH avec la commande de tunnel pour le service de base de données MySQL.
2. Connexion à l'aide de l'application MYSQL Workbench de l'ordinateur local au service de base de données MySQL à l'aide de l'adresse IP localhost 127.0.0.1.
3. Terminal SSH avec la commande tunnel pour l'application NGINX.
4. Connexion à l'aide du navigateur Internet Safari de l'ordinateur local à l'application NGINX à l'aide de l'adresse IP localhost 127.0.0.1.
L'image suivante illustre le déploiement que nous avons effectué jusqu'à présent. Notez que la connexion canalisée à l'adresse IP locale fonctionne pour l'application NGINX et le service de base de données MySQL simultanément avec l'utilisation de plusieurs sessions SSH et tunnels SSH.

Tâche 8 : Nettoyer toutes les applications et tous les services

Exécutez les commandes suivantes pour nettoyer l'application NGINX déployée et le service associé.

kubectl get pods
kubectl delete service my-nginx-svc -n default
kubectl get pods
kubectl get svc
kubectl delete deployment my-nginx --namespace default
kubectl get svc

Exécutez les commandes suivantes pour nettoyer le service de base de données MySQL déployé et le service, le stockage et le mot de passe associés.
```
kubectl delete deployment,svc mysql
kubectl delete pvc mysql-pv-claim
kubectl delete pv mysql-pv-volume
kubectl delete secret mysql-secret
```
L'image suivante illustre le déploiement que nous avons effectué jusqu'à présent, où vous disposez à nouveau d'un environnement propre et pouvez recommencer.

Étapes suivantes

La sécurisation de l'accès aux grappes OKE est une étape cruciale dans le développement d'applications modernes, et la tunnelisation SSH fournit une solution robuste et simple. En mettant en œuvre les étapes de ce tutoriel, les développeurs peuvent protéger leurs ressources, rationaliser leurs flux de travail et garder le contrôle des connexions sensibles pour plusieurs applications. L'intégration de la tunnelisation SSH dans votre configuration OKE améliore non seulement la sécurité, mais réduit également les risques associés à l'exposition des ressources à l'Internet public. Avec ces exercices en place, vous pouvez utiliser vos clusters OKE en toute confiance et vous concentrer sur la création d'applications évolutives, sécurisées et efficaces.

Confirmation

Auteur - Iwan Hoogendoorn (spécialiste du réseau OCI)

Autres ressources d'apprentissage

Explorez d'autres laboratoires sur la page docs.oracle.com/learn ou accédez à plus de contenu d'apprentissage gratuit sur le canal YouTube d'Oracle Learning. De plus, visitez education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir de la documentation sur le produit, visitez Oracle Help Center.

Titre et Copyright

Leverage SSH Tunneling with Oracle Cloud Infrastructure Kubernetes Engine for Secure Application Development

G21949-02

December 2024

Oracle et/ou ses sociétés affiliées.