Remarques :

Ce tutoriel nécessite un accès à Oracle Cloud. Pour vous inscrire à un compte gratuit, reportez-vous à Introduction au niveau gratuit d'Oracle Cloud Infrastructure.
Il utilise des exemples de valeurs pour les informations d'identification, la location et les compartiments Oracle Cloud Infrastructure. Lorsque vous terminez votre atelier, remplacez ces valeurs par celles propres à votre environnement cloud.

Tirer parti du tunneling SSH avec Oracle Cloud Infrastructure Kubernetes Engine pour le développement sécurisé d'applications

Introduction

Quand j'ai obtenu un tunnel SSH avec OKE en travaillant avec l'aide d'Ali Mukadam, je l'ai appelé "magie".

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

Vous l'appelez magique, d'autres l'appellent Science. Là où je suis, ils sont un et le même."

La citation originale est tirée d'un film de Thor :

" Vos ancêtres l'ont appelé Magie, 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, la sécurisation des connexions entre les ressources locales et cloud est essentielle, en particulier lorsque vous utilisez Oracle Cloud Infrastructure Kubernetes Engine (OCI Kubernetes Engine ou OKE). La mise en tunnel SSH offre un moyen simple mais puissant de se connecter en toute sécurité aux clusters 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 le tunneling SSH avec OKE et comment les développeurs peuvent intégrer cette approche dans leur workflow pour une sécurité et une efficacité accrues. De la configuration initiale aux meilleures pratiques, nous couvrons tout ce dont vous avez besoin pour tirer efficacement parti du tunneling SSH dans vos applications basées sur OKE.

L'image suivante illustre les flux de trafic complets de la mise en tunnel SSH de deux applications différentes.

Objectifs

Tirez parti de la tunnellisation SSH avec OKE pour le développement sécurisé d'applications.

Tâche 1 : déploiement du cluster Kubernetes sur OKE (avec un bastion et une instance d'opérateur)

Assurez-vous de disposer d'un cluster Kubernetes déployé sur OKE.

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

Passons rapidement en revue l'environnement OCI OKE pour préparer le terrain.
Réseau cloud virtuel

Connectez-vous à la console OCI, accédez à Fonctions de réseau et à Réseaux cloud virtuels.
- Vérifiez le VCN nommé oke.
- Cliquez sur le VCN oke.
Sous-réseaux

Accédez à la page de détails du VCN.
1. Cliquez sur Sous-réseaux.
2. Vérifiez les sous-réseaux déployés.
Passerelles

Accédez à la page de détails du VCN.
1. Cliquez sur Passerelles Internet.
2. Vérifiez la passerelle Internet créée.
1. Cliquez sur Passerelles NAT.
2. Passez en revue 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. Consultez les listes de sécurité créées.
Pools de noeuds

Accédez à Services de développeur et à Conteneur et artefacts.
1. Cliquez sur Clusters Kubernetes (OKE).
2. Cliquez sur le cluster oke.
1. Cliquez sur Pools de noeuds.
2. Vérifiez les pools de noeuds.
Instances

Accédez à Compute et à Instances.
1. Cliquez sur Instances.
2. Vérifiez les déploiements de noeuds de processus actif Kubernetes.
3. Vérifiez le déploiement de l'hôte Bastion.
4. Vérifiez le déploiement d'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 allons utiliser cette figure dans le reste de ce tutoriel.

Tâche 2 : déploiement d'un serveur Web NGINX sur le cluster Kubernetes

L'opérateur ne peut pas être 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. Le script et la méthode de connexion sont fournis ici : Tâche 4 : utiliser le 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 processus actif à l'aide de la commande kubectl get nodes.
- Vérifiez tous les noeuds de processus actif.

Pour créer un exemple d'application NGINX en cours d'exécution 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. Il crée é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 associé 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 de sous-réseau 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 de l'équilibreur de charge interne.

Cliquez sur Afficher et sur Copier pour obtenir l'OCID de 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. 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 correctement (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. Le service de type équilibreur de charge a été déployé.
Lorsque nous examinons le sous-réseau d'équilibreur de charge interne, nous voyons que le bloc CIDR de ce sous-réseau est 10.0.2.0/27. Le nouveau service de l'équilibreur de charge dispose de l'adresse IP 10.0.2.3.
Pour vérifier l'objet d'équilibreur de charge dans la console OCI, accédez à Fonctions de réseau, à Equilibreur de charge et cliquez sur Equilibreur de charge.
L'image suivante illustre le déploiement que nous avons effectué jusqu'à présent. L'équilibreur de charge est ajouté.

Test du nouveau pod/application

Approche 1 : À partir d'un pod temporaire

Pour vérifier 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é, reportez-vous à Tâche 3 : déploiement d'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. Déployer un exemple de pod pour 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 que le serveur Web et la connectivité utilisant le service d'équilibrage de charge interne fonctionnent.
- Exécutez la commande suivante pour quitter le pod temporaire.
```
exit
```
  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. Le pod déployé temporairement se connecte au service de type IP d'équilibreur de charge pour tester la connectivité.
Approche 2 : à partir de votre ordinateur local
- Exécutez la commande suivante pour tester la connectivité à l'application NGINX de test 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 dispose d'une adresse IP interne, accessible uniquement dans l'environnement Kubernetes.
- Exécutez la commande suivante pour tenter 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 mise en tunnel à l'adresse IP locale ne fonctionne pas.

Tâche 3 : création d'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 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 transférer tout le trafic qui va vers localhost 8080 vers le service de type équilibreur de charge 80. Le service de type équilibreur de charge transmettra ensuite le trafic à l'application NGINX.
```
[opc@o-sqrtga ~]$ k port-forward svc/my-nginx-svc 8080:80
```
  Notez que les messages Forwarding de la fenêtre SSH indiquent 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, puis 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 été ajoutée Gestion 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 par tunnel à l'adresse IP locale fonctionne.

Tâche 5 : déploiement d'un service MySQL Database Service sur le cluster Kubernetes

Nous pouvons atteindre l'application NGINX via le tunnel SSH. Ajoutez maintenant un service de base de données MySQL en cours d'exécution dans l'environnement OKE.

Pour configurer un service de base de données MySQL dans un environnement Kubernetes, vous devez créer les éléments suivants :
- Secret de protection par mot de passe.
- Demande de volume persistant et de volume persistant pour le stockage de base de données.
- Service de base de données MYSQL avec un service de type équilibreur de charge.

Exécutez les commandes suivantes pour :

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 que le service de base de données MySQL a été déployé.
```
kubectl get pod
```
Le service de base de données MySQL a été déployé.
Vérifiez que le service de type équilibreur de charge a été déployé.
```
kubectl get svc
```
Le service de type équilibreur de charge a été déployé.

Pour vérifier l'objet d'équilibreur de charge dans la console OCI, accédez à Fonctions de réseau, à Equilibreur 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 de service de base de données MySQL.
```
mysql -p
```
3. Entrez le mot de passe indiqué dans le fichier mysql-secret.yaml et notez le message de bienvenue du service de base de données MySQL.
4. Exécutez la requête SQL suivante pour afficher la liste de toutes les bases de données MySQL dans le service de base de données.
```
SHOW DATABASES;
```
Accédez à présent à la console de gestion des services 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. 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 localhost 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 sur 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 au service de base de données MySQL.
```
[opc@o-sqrtga ~]$ k port-forward svc/my-mysql-svc 8306:3306
```
3. Notez que les messages Forwarding de la fenêtre SSH indiquent 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 SSH et le tunnel sont établis. Ouvrez l'application MySQL Workbench sur votre ordinateur local.
Cliquez sur + pour ajouter une nouvelle connexion MySQL.
Dans Configuration d'une nouvelle connexion, entrez les informations suivantes.
1. Nom de connexion : entrez un nom.
2. Nom d'hôte : entrez l'adresse IP à 127.0.0.1 (hôte local pendant la mise en tunnel du trafic).
3. Port : entrez le port à utiliser comme 8306, le port que nous utilisons pour le transfert de 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 indiqué dans le fichier mysql-secret.yaml.
2. Cliquez ensuite sur OK.
Cliquez sur Continuer quand même pour ignorer l'avertissement de connexion. Cet avertissement est émis car la version de l'application MySQL Workbench et la version du service de base de données MySQL déployée risquent de ne pas être compatibles.
1. Notez le message indiquant que la connexion a réussi.
2. Cliquez ensuite 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 Please stand by....
Cliquez sur Continuer quand même pour ignorer l'avertissement de connexion.
1. Exécutez la requête SQL suivante pour définir la 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 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 été ajoutée Handling connection for 8306.
Il existe plusieurs entrées car nous avons établi plusieurs connexions, une pour chacune :
- Test.
- Connexion réelle.
- Requête SQL.
- Test que nous avons fait plus tôt (supplément).
Nous pouvons désormais 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 à partir 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 de 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 par tunnel à 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 où vous pouvez recommencer.

Etapes suivantes

La sécurisation de l'accès aux clusters OKE est une étape essentielle dans le développement d'applications modernes, et le tunneling SSH fournit une solution robuste et simple. En implémentant les étapes de ce tutoriel, les développeurs peuvent protéger leurs ressources, rationaliser leurs workflows et garder le contrôle sur les connexions sensibles pour plusieurs applications. L'intégration de la mise en tunnel SSH dans votre configuration OKE améliore non seulement la sécurité, mais réduit également les risques associés à l'exposition des ressources au réseau Internet public. Avec ces pratiques 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.

Remerciements

Auteur - Iwan Hoogendoorn (Spécialiste réseau OCI)

Ressources de formation supplémentaires

Explorez d'autres ateliers sur docs.oracle.com/learn ou accédez à d'autres contenus de formation gratuits sur le canal Oracle Learning YouTube. De plus, visitez le site education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir la documentation produit, consultez le site Oracle Help Center.

Informations relatives au titre et au copyright

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

G21950-02

December 2024

Oracle et/ou ses affiliés.