Observação:

• Este tutorial requer acesso ao Oracle Cloud. Para se inscrever em uma conta gratuita, consulte Conceitos Básicos do Oracle Cloud Infrastructure Free Tier.
• Ele usa valores de exemplo para credenciais, tenancy e compartimentos do Oracle Cloud Infrastructure. Ao concluir seu laboratório, substitua esses valores por valores específicos do seu ambiente de nuvem.

Aproveite o Tunelamento SSH com o Oracle Cloud Infrastructure Kubernetes Engine para Desenvolvimento Seguro de Aplicativos

Introdução

Quando recebi o tunelamento SSH com o OKE trabalhando com a ajuda de Ali Mukadam, chamei de "mágica".

Ele me respondeu com a seguinte mensagem:

"Você a chamou de mágica, outros a chamam de ciência. Onde eu estou, eles são um e o mesmo".

A citação original é de um filme de Thor:

"Seus antepassados chamaram de Magia, mas você a chama de Ciência. Eu Venho de uma Terra em que São Uma e a Mesma".

Então, o que é essa magia?

No desenvolvimento de aplicativos modernos, é essencial proteger conexões entre recursos locais e baseados em nuvem, especialmente ao trabalhar com o Oracle Cloud Infrastructure Kubernetes Engine (OCI Kubernetes Engine ou OKE). O tunelamento SSH oferece uma maneira simples, mas poderosa, de estabelecer conexão segura com clusters do OKE, permitindo que os desenvolvedores gerenciem e interajam com recursos sem expô-los à internet pública. Este tutorial explora como configurar o tunelamento SSH com o OKE e como os desenvolvedores podem integrar essa abordagem em seu fluxo de trabalho para maior segurança e eficiência. Desde a configuração inicial até as melhores práticas, abordaremos tudo o que você precisa para aproveitar o tunelamento SSH de forma eficaz em seus aplicativos baseados no OKE.

A imagem a seguir ilustra os fluxos de tráfego completos do tunelamento SSH de dois aplicativos diferentes.

Objetivos

• Aproveite o tunelamento SSH com o OKE para desenvolvimento seguro de aplicativos.

Tarefa 1: Implantar o Cluster do Kubernetes no OKE (com uma Instância do Bastion e do Operador)

Certifique-se de ter um cluster do Kubernetes implantado no OKE.

• Para implantar o cluster do Kubernetes no OKE, use um dos seguintes métodos:

  • Implemente um Cluster Kubernetes com o Terraform usando o Oracle Cloud Infrastructure Kubernetes Engine: Implemente um único cluster Kubernetes no OKE usando o Terraform.

  • Usar o Terraform para Implantar Vários Clusters do Kubernetes em diferentes Regiões do OCI usando o OKE e Criar uma Rede de Malha Completa usando RPC: Implantar vários clusters do Kubernetes em várias regiões no OKE usando o Terraform.

  • Tarefa 1: Criar um Novo Cluster do Kubernetes e Verificar os Componentes: Implantar um cluster do Kubernetes no OKE usando o modo Criação Rápida.

  • Tarefa 1: Implantar um Cluster do Kubernetes usando o OKE: Implante um cluster do Kubernetes no OKE usando o modo Criação Personalizada.

  Neste tutorial, usaremos Implantar um Cluster do Kubernetes com o Terraform usando o Oracle Cloud Infrastructure Kubernetes Engine como o cluster base do Kubernetes no OKE para explicar como podemos usar um túnel SSH para acessar um aplicativo baseado em contêiner implantado no OKE com localhost.

  Vamos analisar rapidamente o ambiente do OCI OKE para definir o estágio.

• VCN (Rede Virtual na Nuvem)

  Faça log-in na Console do OCI, navegue até Rede e Redes Virtuais na Nuvem.

  • Verifique a VCN chamada oke.

  • Clique na VCN oke.

  

• Sub-redes

  Vá para a página de detalhes da VCN.

  1. Clique em Sub-redes.
  2. Verifique as sub-redes implantadas.

  

• Gateways

  Vá para a página de detalhes da VCN.

  1. Clique em Gateways de Internet.
  2. Verifique o gateway de internet criado.

  

  1. Clique em Gateways NAT.
  2. Verifique o gateway NAT criado.

  

  1. Clique em Gateways de Serviço.
  2. Verifique o gateway de serviço criado.

  

  1. Clique em Listas de Segurança.
  2. Verifique as listas de segurança criadas.

  

• Pools de Nós

  Navegue até Developer Services e Container & Artifacts.

  1. Clique em Clusters do Kubernetes (OKE).
  2. Clique no cluster oke.

  

  1. Clique em Pools de Nós.
  2. Revise os pools de nós.

  

• Instâncias

  Navegue até Compute e Instances.

  1. Clique em Instâncias.
  2. Verifique as implantações de Nós de trabalho do Kubernetes.
  3. Verifique a implantação do Host Bastion.
  4. Verifique a implantação do Kubernetes Operator.

  

• A imagem a seguir ilustra uma visão geral completa do que será nosso ponto de partida para o conteúdo restante deste tutorial.

  

• A imagem a seguir ilustra uma visão simplificada da figura anterior. Usaremos essa figura no restante deste tutorial.

  

Tarefa 2: Implantar um Servidor Web NGINX no Cluster do Kubernetes

O operador não pode ser acessado diretamente pela internet e temos que passar pelo Bastion host.

• Neste tutorial, estamos usando um script SSH fornecido por Ali Mukadam para se conectar ao operador usando um único comando SSH. Este script e método para conexão são fornecidos aqui: Tarefa 4: Usar o Bastion e o Operador para Verificar a Conectividade. Você precisará desse script mais tarde neste tutorial, portanto, certifique-se de usá-lo.

  • Configure uma sessão SSH para o operador do Kubernetes.

  • Verifique os Nós de Trabalho ativos com o comando kubectl get nodes.

  • Verifique todos os Nós de Trabalho ativos.

  

• Para criar um aplicativo NGINX de amostra que esteja sendo executado dentro de um contêiner, crie um arquivo YAML chamado modified2_nginx_ext_lb.yaml com o código a seguir no operador.

  O arquivo YAML contém o código para criar o aplicativo do servidor Web NGINX com 3 réplicas e também criará um serviço do tipo balanceador de carga.

  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
  

• Queremos tornar esse aplicativo acessível internamente e decidir criar o serviço do tipo balanceador de carga anexado à sub-rede privada do balanceador de carga.

  Para designar o serviço do tipo balanceador de carga a uma sub-rede privada do balanceador de carga, você precisa do OCID da sub-rede privada do balanceador de carga e adicionar o código a seguir na seção anotações.

  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"
  

• Para obter o OCID da sub-rede da sub-rede privada do balanceador de carga, clique na sub-rede interna do balanceador de carga.

  

  Clique em Mostrar e Copiar para obter o OCID completo da sub-rede do balanceador de carga privado. Use esse OCID na seção anotações.

  

• Para implantar o aplicativo NGINX e o serviço do tipo balanceador de carga, execute os seguintes comandos:

  1. Para criar o arquivo YAML no operador.

     nano modified2_nginx_ext_lb.yaml
     

  2. Para implantar o aplicativo NGINX com o serviço do tipo balanceador de carga.

     kubectl apply -f modified2_nginx_ext_lb.yaml
     

     Para verificar se o aplicativo NGINX foi implantado com sucesso (não mostrado na imagem).

     kubectl get pods
     

  3. Para verificar se o serviço do tipo balanceador de carga foi implantado com sucesso.

     kubectl get svc
     

  4. Observe que o serviço do tipo balanceador de carga foi implantado com sucesso.

  

• Quando olhamos para a sub-rede do balanceador de carga interno, podemos ver que o bloco CIDR dessa sub-rede é 10.0.2.0/27. O novo serviço do balanceador de carga tem o endereço IP 10.0.2.3.

  

• Para verificar o objeto do balanceador de carga na Console do OCI, navegue até Rede, Balanceador de carga e clique em Balanceador de Carga.

  

• A imagem a seguir ilustra a implantação que fizemos até agora. Observe que o balanceador de carga é adicionado.

  

Testar o Novo Pod/Aplicativo

• Abordagem 1: De um pod temporário

  Para testar se o aplicativo NGINX recém-implantado está funcionando com o serviço do tipo balanceador de carga, podemos fazer um teste de conectividade interna usando um pod temporário.

  Há várias maneiras de testar a conectividade com o aplicativo, uma maneira seria abrir um navegador e testar se você pode acessar a página da web. Mas quando não temos um navegador disponível, podemos fazer outro teste rápido implantando um pod temporário.

  Para criar um pod temporário e usá-lo para testes de conectividade, consulte Tarefa 3: Implantar um Aplicativo e Serviço Web de Amostra.

  • Execute o seguinte comando:

    1. Para obter o endereço IP do serviço do balanceador de carga interno.

       kubectl get svc
       

    2. Para implantar um pod de amostra para testar a conectividade do aplicativo Web.

       kubectl run --rm -i -t --image=alpine test-$RANDOM -- sh
       

    3. Para testar a conectividade com o servidor Web usando o wget.

       wget -qO- http://<ip-of-internal-lb-service>
       

    4. Observe que o código HTML que o servidor Web retorna, confirmando o servidor Web e a conectividade usando o serviço de balanceamento de carga interno, estão funcionando.

    

  • Execute o comando a seguir para sair do pod temporário.

    exit
    

    Observe que o pod é excluído imediatamente após fecharmos a interface da linha de comando.

  • A imagem a seguir ilustra a implantação que fizemos até agora. Observe que o pod implantado temporariamente está se conectando ao serviço do tipo IP do balanceador de carga para testar a conectividade.

    

• Abordagem 2: Do seu computador local

  • Execute o comando a seguir para testar a conectividade com o aplicativo NGINX de teste com o serviço do tipo balanceador de carga do nosso laptop local.

    iwhooge@iwhooge-mac ~ % wget -qO- <ip-of-internal-lb-service>
    

    Como você observará, no momento isso não está funcionando, pois o serviço do tipo balanceador de carga tem um endereço IP interno e só pode ser acessado dentro do ambiente do Kubernetes.

  • Execute o comando a seguir para tentar acessar o aplicativo NGINX usando o endereço IP local com uma porta personalizada 8080.

    iwhooge@iwhooge-mac ~ % wget -qO- 127.0.0.1:8080
    iwhooge@iwhooge-mac ~ %
    

    Por enquanto, isso não está funcionando, mas usaremos o mesmo comando posteriormente neste tutorial depois de configurarmos o túnel SSH.

• A imagem a seguir ilustra a implantação que fizemos até agora. Observe que a conexão tunelada com o endereço IP local não está funcionando.

  

Tarefa 3: Criar um Script de Configuração SSH com Entradas Localhost

Para permitir que o túnel SSH funcione, precisamos adicionar a entrada a seguir em nosso arquivo de configuração SSH localizado na pasta /Users/iwhooge/.ssh.

• Execute o comando nano /Users/iwhooge/.ssh/config para editar o arquivo de configuração.

• Adicione a linha a seguir na seção Host operator47.

  LocalForward 8080 127.0.0.1:8080
  

• A saída do arquivo de configuração 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 %
  

• Observe que o comando LocalForward é adicionado ao arquivo de configuração SSH.

  

Tarefa 4: Configurar o Túnel SSH e Conectar-se ao Servidor Web NGINX usando Localhost

• Se você estiver conectado com SSH ao operador, desconecte essa sessão.

  1. Reconecte-se ao operador usando o script novamente.

     iwhooge@iwhooge-mac ~ % ssh operator47
     

  2. Execute o comando a seguir para obter o endereço IP do serviço do balanceador de carga interno.

     [opc@o-sqrtga ~]$ kubectl get svc
     

  3. Execute o comando a seguir no operador (janela SSH) para configurar o túnel SSH e encaminhar todo o tráfego que vai para o host local 8080 para o serviço do tipo balanceador de carga 80. O serviço do tipo balanceador de carga encaminhará o tráfego eventualmente para o aplicativo NGINX.

     [opc@o-sqrtga ~]$ k port-forward svc/my-nginx-svc 8080:80
     

     Observe as mensagens de Encaminhamento na janela SSH que a porta localhost 8080 é encaminhada para a porta 80.

     Forwarding from 127.0.0.1:8080 -> 80
     Forwarding from [::1]:8080 -> 80
     

  

• Teste a conectividade do seu computador local e verifique se a conectividade funciona usando um endereço IP local (127.0.0.1) com a porta 8080 e veja se isso permitirá que você se conecte ao aplicativo NGINX dentro do ambiente OKE.

• Abra um novo terminal e execute o comando a seguir para testar a conectividade.

  iwhooge@iwhooge-mac ~ % wget -qO- 127.0.0.1:8080
  

• Observe que você obterá a seguinte saída no terminal do seu computador local, o que significa que ele está funcionando.

  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 ~ %
  

• Na janela SSH do operador, observe que a saída foi alterada e uma nova linha adicionou Tratando a conexão para 8080.

  

• Um teste rápido usando um navegador da Web mostra a saída a seguir.

  

• A imagem a seguir ilustra a implantação que fizemos até agora. Observe que a conexão encapsulada com o endereço IP local está funcionando.

  

Tarefa 5: Implantar um MySQL Database Service no Cluster do Kubernetes

Podemos acessar o aplicativo NGINX por meio do túnel SSH; agora, adicione um serviço de banco de dados MySQL que esteja sendo executado no ambiente do OKE.

• Para configurar um serviço de banco de dados MySQL dentro de um ambiente do Kubernetes, você precisa criar:

  • Um segredo para proteção por senha.
  • Um Volume Persistente e uma Reivindicação de Volume Persistente para armazenamento de banco de dados.
  • O serviço de banco de dados MYSQL com um serviço do tipo balanceador de carga.

• Execute os comandos a seguir para:

  1. Crie a senha para o serviço de banco de dados MySQL.

     nano mysql-secret.yaml
     

     Copie o código YAML a seguir em mysql-secret.yaml.

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

  2. Aplique o código YAML.

     kubectl apply -f mysql-secret.yaml
     

  3. Crie o armazenamento para o serviço de banco de dados MySQL.

     nano mysql-storage.yaml
     

     Copie o código YAML a seguir em 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
     

  4. Aplique o código YAML.

     kubectl apply -f mysql-storage.yaml
     

  5. Crie o serviço de banco de dados MySQL e o serviço do tipo balanceador de carga.

     nano mysql-deployment.yaml
     

     Copie o código YAML a seguir em 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
     

  6. Aplique o código YAML.

     kubectl apply -f mysql-deployment.yaml
     

  7. Verifique se o serviço de banco de dados MySQL foi implantado com sucesso.

     kubectl get pod
     

  8. Observe que o serviço de banco de dados MySQL foi implantado com sucesso.

  9. Verifique se o serviço do tipo balanceador de carga foi implantado com sucesso.

     kubectl get svc
     

  10. Observe que o serviço do tipo balanceador de carga foi implantado com sucesso.

  

• Para verificar o objeto do balanceador de carga na Console do OCI, navegue até Rede, Balanceador de carga e clique no balanceador de carga.

  

• Para acessar a console do terminal do serviço de banco de dados MySQL, podemos usar o comando kubectl exec e o comando do túnel SSH localhost.

  1. Execute o comando a seguir para acessar a console do terminal por meio do operador.

     kubectl exec --stdin --tty mysql-74f8bf98c5-bl8vv -- /bin/bash
     

  2. Execute o comando a seguir para acessar a console do serviço de banco de dados MySQL.

     mysql -p
     

  3. Informe a senha especificada no arquivo mysql-secret.yaml e observe a mensagem de boas-vindas do serviço de banco de dados MySQL.

  4. Execute a consulta SQL a seguir para ver uma lista de todos os bancos de dados MySQL dentro do serviço de banco de dados.

     SHOW DATABASES;
     

  

  Agora acesse a console de gerenciamento de serviços de banco de dados MySQL no ambiente do Kubernetes.

• A imagem a seguir ilustra a implantação que fizemos até agora. Observe que o serviço MySQL com o serviço do tipo balanceador de carga está implantado.

  

Tarefa 6: Adicionar Outras Entradas de Localhost Dentro do Script de Configuração SSH

Adicione entradas de localhost adicionais dentro do script de configuração SSH para acessar o novo serviço de banco de dados MySQL.

• Para permitir que o túnel SSH funcione para o serviço de banco de dados MySQL, precisamos adicionar a entrada a seguir em nosso arquivo de configuração SSH localizado na pasta /Users/iwhooge/.ssh.

• Execute o comando nano /Users/iwhooge/.ssh/config para editar o arquivo de configuração.

• Adicione a linha a seguir na seção Host operator47.

  LocalForward 8306 127.0.0.1:8306
  

• Saída do arquivo de configuração 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
  

• Observe que o comando LocalForward é adicionado ao arquivo de configuração SSH.

  

Tarefa 7: Configurar o Túnel SSH e Estabelecer Conexão com o MySQL Database usando o Localhost

• Para testar a conexão com o serviço de banco de dados MySQL do computador local, faça download do MySQL Workbench e instale-o no computador local.

  1. Abra um novo terminal para o operador usando o script novamente. Deixe o outro terminal aberto.

     iwhooge@iwhooge-mac ~ % ssh operator47
     

  2. Execute o comando a seguir na janela SSH do operador para configurar o túnel SSH e encaminhar todo o tráfego que vai para o host local 8306 para o serviço do tipo balanceador de carga 3306. O serviço do tipo balanceador de carga encaminhará o tráfego eventualmente para o serviço de banco de dados MySQL.

     [opc@o-sqrtga ~]$ k port-forward svc/my-mysql-svc 8306:3306
     

  3. Observe as mensagens de Encaminhamento na janela SSH que a porta localhost 8306 é encaminhada para a porta 3306.

     Forwarding from 127.0.0.1:8306 -> 3306
     Forwarding from [::1]:8306 -> 3306
     

  

• O aplicativo MySQL Workbench é instalado e a sessão SSH e o túnel são estabelecidos. Abra o aplicativo MySQL Workbench em seu computador local.

• Clique em + para adicionar uma nova conexão MySQL.

  

• Em Configurar Nova Conexão, especifique as informações a seguir.

  1. Nome da Conexão: Informe um nome.
  2. Nome do Host: Informe o endereço IP a ser 127.0.0.1 (localhost, pois estamos tunelando o tráfego).
  3. Porta: Informe a porta a ser 8306, a porta que usamos para o encaminhamento do túnel local para o serviço de banco de dados MySQL.
  4. Clique em Testar Conexão.

  

  1. Senha: Informe a senha especificada no arquivo mysql-secret.yaml.
  2. Clique em OK.

  

• Clique em Continuar Mesmo Assim para desconsiderar o aviso de conexão. Esse aviso é fornecido como a versão do aplicativo MySQL Workbench e a versão do serviço de banco de dados MySQL implantado pode não ser compatível.

  

  1. Observe a mensagem de conexão bem-sucedida.
  2. Clique em OK.
  3. Clique em OK para salvar a conexão MySQL.

  

• Clique na conexão salva MySQL para abrir a sessão.

  

• Observe a mensagem Por favor, aguarde....

  

• Clique em Continuar Mesmo Assim para desconsiderar o aviso de conexão.

  

  1. Execute a consulta SQL a seguir para definir uma lista de todos os bancos de dados MySQL dentro do serviço de banco de dados.

     SHOW DATABASES;
     

  2. Clique no ícone de raio.

  3. Observe a saída de todos os bancos de dados MySQL dentro do serviço de banco de dados MySQL.

  

• Na janela SSH do operador, observe que a saída foi alterada e uma nova linha adicionou Tratando a conexão para 8306.

• Existem várias entradas porque fizemos várias conexões, uma para cada:

  • Testar.
  • Conexão real.
  • Consulta SQL.
  • Teste que fizemos anteriormente (adicional).

  

• Agora podemos abrir várias sessões SSH para o operador e executar vários comandos de túnel para diferentes aplicativos simultaneamente. Observe as seguintes janelas.

  1. O terminal SSH com o comando de túnel para o serviço de banco de dados MySQL.
  2. A conexão usando o aplicativo MYSQL Workbench do computador local para o serviço de banco de dados MySQL usando o endereço IP localhost 127.0.0.1.
  3. O terminal SSH com o comando de túnel para o aplicativo NGINX.
  4. A conexão usando o Navegador de Internet Safari do computador local para o aplicativo NGINX usando o endereço IP localhost 127.0.0.1.

  

• A imagem a seguir ilustra a implantação que fizemos até agora. Observe que a conexão tunelada com o endereço IP local está funcionando para o aplicativo NGINX e o serviço de banco de dados MySQL simultaneamente com o uso de várias sessões SSH e túneis SSH.

  

Tarefa 8: Limpar todos os Aplicativos e Serviços

• Execute os comandos a seguir para limpar o aplicativo NGINX implantado e o serviço associado.

  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
  

• Execute os comandos a seguir para limpar o serviço de banco de dados MySQL implantado e o serviço, armazenamento e senha associados.

  kubectl delete deployment,svc mysql
  kubectl delete pvc mysql-pv-claim
  kubectl delete pv mysql-pv-volume
  kubectl delete secret mysql-secret
  

• A imagem a seguir ilustra a implantação que fizemos até agora, onde você tem um ambiente limpo novamente e pode começar de novo.

  

Próximas Etapas

A proteção do acesso a clusters do OKE é uma etapa crítica no desenvolvimento de aplicativos modernos, e o tunelamento SSH fornece uma solução robusta e direta. Ao implementar as etapas deste tutorial, os desenvolvedores podem proteger seus recursos, agilizar seus fluxos de trabalho e manter o controle sobre conexões confidenciais para vários aplicativos. A integração do tunelamento SSH na configuração do OKE não apenas aumenta a segurança, mas também minimiza os riscos associados à exposição de recursos à internet pública. Com essas práticas em vigor, você pode usar com confiança seus clusters OKE e se concentrar na criação de aplicativos escaláveis, seguros e eficientes.

Confirmações

• Autor - Iwan Hoogendoorn (Especialista em Rede da OCI)

Mais Recursos de Aprendizagem

Explore outros laboratórios em docs.oracle.com/learn ou acesse mais conteúdo de aprendizado gratuito no canal Oracle Learning YouTube. Além disso, visite education.oracle.com/learning-explorer para se tornar um Oracle Learning Explorer.

Para obter a documentação do produto, visite o Oracle Help Center.

---

Título e Informações de Copyright

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

G21954-02

December 2024

Copyright ©2024,

Oracle e/ou suas empresas afiliadas.