Observação:

Execute o Kubernetes no Oracle Linux

Introdução

Kubernetes é grego para piloto ou ajudante - em outras palavras, a pessoa que segue comandos e dirige um navio para seu objetivo final (em vez de ser o Capitão dando ordens). Para isso, o Kubernetes é uma plataforma extensível de código aberto para implantação, gerenciamento e dimensionamento de aplicativos em contêineres. Ele consegue isso usando várias ferramentas de linha de comando. Este laboratório usa um dos chamados kubectl junto com arquivos YAML para definir os atributos necessários para a organização que está implantando o aplicativo e entender como configurar e manter o aplicativo depois de implantá-lo.

Todas as implantações em um cluster do Kubernetes são representadas como objetos. Esses objetos implantados usam arquivos YAML baseados em texto para fornecer detalhes do estado necessário de qualquer aplicativo implantado no cluster. Estes arquivos YAML podem descrever o seguinte:

Este terceiro ponto, embora importante, é complicado sem entender o básico. Portanto, manteremos esse tópico por enquanto e lidaremos com ele em futuros tutoriais.

Este tutorial funciona com o Kubernetes em execução em um Oracle Cloud Native Environment compacto no Oracle Linux. A intenção não é ser um "balcão único" para tudo o que é necessário para administrar uma implantação de produção. Em vez disso, ele apresenta as habilidades necessárias para implantar um aplicativo de amostra de trabalho.

Objetivos

Pré-requisitos

Um sistema Oracle Linux 8 ou posterior com a seguinte configuração:

Configurar Ambiente de Laboratório

Observação: ao usar o ambiente de laboratório gratuito, consulte Conceitos Básicos do Oracle Linux Lab para obter conexão e outras instruções de uso.

Informações: O ambiente de laboratório gratuito implanta o Oracle Cloud Native Environment no nó fornecido, pronto para a criação de ambientes. Esta implantação leva aproximadamente de 8 a 10 minutos para ser concluída após o início. Portanto, talvez você queira se afastar enquanto isso é executado e, em seguida, retornar para concluir o laboratório.

  1. Se ainda não estiver conectado, abra um terminal e conecte-se via ssh ao sistema ocne-node01.

    ssh oracle@<ip_address_of_ol_node>
    
  2. Confirme se o ambiente está pronto.

    kubectl get pods -A
    

    Exemplo de Saída:

    [oracle@ocne-node01 ~]$ kubectl get pods -A
    NAMESPACE                      NAME                                             READY   STATUS    RESTARTS   AGE
    externalip-validation-system   externalip-validation-webhook-7988bff847-8ws2v   1/1     Running   0          3m18s
    kube-system                    coredns-7cbc77dbc7-qxqth                         1/1     Running   0          3m18s
    kube-system                    coredns-7cbc77dbc7-r9bgj                         1/1     Running   0          3m18s
    kube-system                    etcd-ocne-node01                                 1/1     Running   0          3m37s
    kube-system                    kube-apiserver-ocne-node01                       1/1     Running   0          3m37s
    kube-system                    kube-controller-manager-ocne-node01              1/1     Running   0          3m37s
    kube-system                    kube-flannel-ds-vcwzn                            1/1     Running   0          3m18s
    kube-system                    kube-proxy-7lx59                                 1/1     Running   0          3m18s
    kube-system                    kube-scheduler-ocne-node01                       1/1     Running   0          3m37s
    kubernetes-dashboard           kubernetes-dashboard-5d5d4947b5-7pffh            1/1     Running   0          3m18s
    

Criar uma Implantação em um Pod e Detalhes da Solicitação

No Kubernetes, a implantação é um termo técnico que se refere a um arquivo que controla o comportamento e as características de um pod. Os administradores usam implantações para instruir o aplicativo sobre o que fazer, e o Kubernetes executa a tarefa para atingir esse estado.

Os exemplos usam uma imagem que contém um servidor web nginx pequeno que retém o IP de origem das solicitações que recebe por meio de um cabeçalho HTTP.

  1. Crie uma implantação do echoserver.

    kubectl create deployment test --image=k8s.gcr.io/echoserver:1.4
    
  2. Liste todos os Pods no cluster.

    kubectl get pods
    

    Exemplo de Saída:

    [oracle@ocne-node01 ~]$ kubectl get pods
    NAME                    READY   STATUS    RESTARTS   AGE
    test-6c486b6d76-467p7   1/1     Running   0          53s
    

    Observação: O nome do Pod contém um valor de sufixo que varia toda vez que implanta o Pod.

  3. Use JSONPath para designar o nome do Pod a uma variável.

    TESTPOD=$(kubectl get pods -o jsonpath='{ $.items[*].metadata.name }')
    
  4. Teste a atribuição de variável.

    O comando kubectl get pods também permite transmitir um nome de pod como um parâmetro para exibir somente as informações desse Pod.

    kubectl get pods $TESTPOD
    
  5. Solicite informações selecionadas sobre o Pod.

    kubectl get pod $TESTPOD --output custom-columns=NAME:metadata.name,NODE_IP:status.hostIP,POD_IP:status.podIP
    

    Exemplo de Saída:

    [oracle@ocne-node01 ~]$ kubectl get pod $TESTPOD --output custom-columns=NAME:metadata.name,NODE_IP:status.hostIP,POD_IP:status.podIP
    NAME                    NODE_IP      POD_IP
    test-6c486b6d76-467p7   10.0.0.140   10.244.0.7
    
  6. Obtenha os detalhes do Pod.

    kubectl describe pod $TESTPOD
    

    Exemplo de Saída:

    [oracle@ocne-node01 ~]$ kubectl describe pod test-6c486b6d76-467p7
    Name:         test-6c486b6d76-467p7
    Namespace:    default
    Priority:     0
    Node:         ocne-node01/10.0.0.140
    Start Time:   Tue, 28 Jun 2022 19:21:27 +0000
    Labels:       app=test
                  pod-template-hash=6c486b6d76
    Annotations:  <none>
    Status:       Running
    IP:           10.244.0.7
    IPs:
      IP:           10.244.0.7
    Controlled By:  ReplicaSet/test-6c486b6d76
    Containers:
      echoserver:
        Container ID:   cri-o://5b7866a27722ec0998cd9fe74945fb82b4dd9ed4c5c80671d9e8aa239c7008a4
        Image:          k8s.gcr.io/echoserver:1.4
        Image ID:       k8s.gcr.io/echoserver@sha256:5d99aa1120524c801bc8c1a7077e8f5ec122ba16b6dda1a5d3826057f67b9bcb
        Port:           <none>
        Host Port:      <none>
        State:          Running
          Started:      Tue, 28 Jun 2022 19:21:30 +0000
        Ready:          True
        Restart Count:  0
        Environment:    <none>
        Mounts:
          /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-d67ph (ro)
    Conditions:
      Type              Status
      Initialized       True 
      Ready             True 
      ContainersReady   True 
      PodScheduled      True 
    Volumes:
      kube-api-access-d67ph:
        Type:                    Projected (a volume that contains injected data from multiple sources)
        TokenExpirationSeconds:  3607
        ConfigMapName:           kube-root-ca.crt
        ConfigMapOptional:       <nil>
        DownwardAPI:             true
    QoS Class:                   BestEffort
    Node-Selectors:              <none>
    Tolerations:                 node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                                 node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
    Events:
      Type    Reason     Age   From               Message
      ----    ------     ----  ----               -------
      Normal  Scheduled  21m   default-scheduler  Successfully assigned default/test-6c486b6d76-467p7 to ocne-node01
      Normal  Pulling    21m   kubelet            Pulling image "k8s.gcr.io/echoserver:1.4"
      Normal  Pulled     21m   kubelet            Successfully pulled image "k8s.gcr.io/echoserver:1.4" in 3.102843235s
      Normal  Created    21m   kubelet            Created container echoserver
      Normal  Started    21m   kubelet            Started container echoserver
    

Criar uma Implantação com um Arquivo YAML

Usando os manifestos de Implantação do Kubernetes, defina como implantar um aplicativo no cluster do Kubernetes e forneça acesso a outra funcionalidade do Kubernetes, como autorreparo, escalabilidade, controle de versão e atualizações contínuas. Este laboratório não abordará essa funcionalidade mais complexa fornecida no Kubernetes. Em vez disso, ilustra como usar um arquivo de manifesto muito básico para implantar um aplicativo.

Um arquivo de manifesto de Implantação é gravado em JSON ou YAML. Embora possível usar JSON, o YAML é muito mais popular devido à sua flexibilidade, legibilidade e a capacidade de incluir comentários descritivos para esclarecer aspectos da implantação final.

Ao executar uma Implantação, um Pod é atualizado por meio de uma série de atualizações declarativas para atingir o estado desejado para o aplicativo em execução.

Embora todos os detalhes no deployment.yaml sejam essenciais para que o Kubernetes possa aprovar a solicitação de implantação, o seguinte destaca algumas das partes mais vitais:

Consulte a documentação de Implantações upstream para obter mais informações sobre esses outros campos.

  1. Crie o arquivo de Implantação.

    cat << 'EOF' | tee mydeployment.yaml > /dev/null
    apiVersion: apps/v1
    kind: Deployment
    metadata:
     name: echo1
    spec:
     selector:
       matchLabels: 
         app: echo1
     template:
       metadata:
         labels:
           app: echo1
       spec:
         containers:
         - name: echoserver
           image: k8s.gcr.io/echoserver:1.4
    EOF
    
  2. Implante o aplicativo em um Pod usando o arquivo de manifesto de Implantação.

    kubectl apply -f mydeployment.yaml
    

    Exemplo de Saída:

    [[oracle@ocne-node01 ~]$ kubectl apply -f mydeployment.yaml
    deployment.apps/echo1 created
    
  3. Liste o Pod gerenciado pela implantação.

    kubectl get pods -l app=echo1
    

    Exemplo de Saída:

    [oracle@ocne-node01 ~]$ kubectl get pods -l app=echo1
    NAME                     READY   STATUS    RESTARTS   AGE
    echo1-7cbf6dfb96-4cgq7   1/1     Running   0          24s
    
    • A opção -l ou --selector= fornece um seletor (consulta de rótulo) para filtrar. Essa opção suporta '=', '==' e '!='.(por exemplo, -l key1=value1,key2=value2)

    Observação: Lembre-se de que o nome do Pod contém um valor de sufixo que varia toda vez que implanta o Pod.

  4. Verifique se a Implantação foi bem-sucedida.

    kubectl get deploy echo1
    

    Exemplo de Saída:

    [oracle@ocne-node01 ~]$ kubectl get deploy echo1
    NAME    READY   UP-TO-DATE   AVAILABLE   AGE
    echo1   1/1     1            1           16m
    
    • A opção deploy é curta para deployments. O comando kubectl permite o uso de uma sintaxe abreviada para muitas de suas opções. Para obter mais detalhes, execute kubectl --help.
  5. Retornar informações mais detalhadas para uma implantação.

    kubectl describe deploy echo1
    

    Exemplo de Saída:

    [oracle@ocne-node01 ~]$ kubectl describe deploy echo1
    Name:                   echo1
    Namespace:              default
    CreationTimestamp:      Tue, 28 Jun 2022 20:20:40 +0000
    Labels:                 <none>
    Annotations:            deployment.kubernetes.io/revision: 1
    Selector:               app=echo1
    Replicas:               1 desired | 1 updated | 1 total | 1 available | 0 unavailable
    StrategyType:           RollingUpdate
    MinReadySeconds:        0
    RollingUpdateStrategy:  25% max unavailable, 25% max surge
    Pod Template:
      Labels:  app=echo1
      Containers:
       echoserver:
        Image:        k8s.gcr.io/echoserver:1.4
        Port:         <none>
        Host Port:    <none>
        Environment:  <none>
        Mounts:       <none>
      Volumes:        <none>
    Conditions:
      Type           Status  Reason
      ----           ------  ------
      Available      True    MinimumReplicasAvailable
      Progressing    True    NewReplicaSetAvailable
    OldReplicaSets:  <none>
    NewReplicaSet:   echo1-7cbf6dfb96 (1/1 replicas created)
    Events:
      Type    Reason             Age   From                   Message
      ----    ------             ----  ----                   -------
      Normal  ScalingReplicaSet  23m   deployment-controller  Scaled up replica set echo1-7cbf6dfb96 to 1
    

Usar Serviço ClusterIP

Apesar de implantar com sucesso a echo1 Implantação em um Pod, ele não será muito usado se os usuários finais não puderem acessá-la internamente ou na rede. Esse acesso é onde um Serviço é útil, pois ele expõe uma Implantação à rede.

O tipo de serviço padrão do Kubernetes é ClusterIP. No entanto, você não pode acessar um serviço ClusterIP pela internet, mas pode usar o proxy Kubernetes. Consulte a documentação upstream para obter mais informações sobre Proxies.

Esta seção expõe echo1 e cria uma comunicação entre serviços dentro do cluster usando um Oracle Linux Pod, demonstrando a comunicação entre os componentes front-end e back-end de seu aplicativo.

  1. Obtenha uma lista de nós.

    kubectl get nodes
    

    Exemplo de Saída:

    [oracle@ocne-node01 ~]$ kubectl get nodes
    NAME          STATUS   ROLES    AGE     VERSION
    ocne-node01   Ready    <none>   4h27m   v1.22.8+1.el8
    

    Nós são os sistemas físicos ou máquinas virtuais para a implantação de Pods.

  2. Consulte o modo kube-proxy.

    A execução de kube-proxy no modo iptables faz com que os pacotes enviados a um Serviço ClusterIP nunca sejam NAT'd de origem.

    curl -w "\n" http://localhost:10249/proxyMode
    
    • O comando kube-proxy faz listening na porta 10249 no nó em que está sendo executado.
  3. Crie o Serviço ClusterIP.

    kubectl expose deployment echo1 --name=clusterip-service --port=80 --target-port=8080
    
  4. Obtenha o endereço IP designado ao cluster.

    kubectl get svc clusterip-service
    

    Exemplo de Saída:

    [oracle@ocne-node01 ~]$ kubectl get svc clusterip-service
    NAME                TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
    clusterip-service   ClusterIP   10.108.107.54   <none>        80/TCP    13s
    

    Anote o endereço CLUSTER-IP na saída.

  5. Crie um pod no mesmo cluster para acessar o Serviço ClusterIP.

    kubectl run ol -it --image=oraclelinux:8 --restart=Never --rm
    

    Esse comando criará um Pod executando um contêiner do Oracle Linux 8 no modo interativo e apresentará um prompt de comando.

    Exemplo de Saída:

    [oracle@ocne-node01 ~]$ kubectl run ol -it --image=oraclelinux:8 --restart=Never --rm
    If you don't see a command prompt, try pressing enter.
    [root@ol /]#
    
  6. Obtenha o endereço IP do contêiner do Oracle Linux.

    ip -br a
    

    Exemplo de Saída:

    [root@ol /]# ip -br a
    lo               UNKNOWN        127.0.0.1/8 ::1/128 
    eth0@if12        UP             10.244.0.9/24 fe80::146f:2cff:fe73:b528/64
    
  7. Teste o servidor Web nginx em echo1.

    curl -w "\n" <CLUSTER-IP_ADDRESS>
    

    Use o endereço CLUSTER-IP da saída anterior.

    Exemplo de Saída:

    [root@ol /]# curl -w "\n" 10.108.107.54
    CLIENT VALUES:
    client_address=10.244.0.9
    command=GET
    real path=/
    query=nil
    request_version=1.1
    request_uri=http://10.108.107.54:8080/
    
    SERVER VALUES:
    server_version=nginx: 1.10.0 - lua: 10001
    
    HEADERS RECEIVED:
    accept=*/*
    host=10.108.107.54
    user-agent=curl/7.61.1
    BODY:
    -no body in request-
    

    A saída mostra a solicitação do Oracle Linux e tratada pelo Serviço ClusterIP usando a Implantação echo1.

  8. Saia do contêiner.

    exit
    

    Exemplo de Saída:

    [root@ol /]# exit
    exit
    pod "ol" deleted
    

Usar o Serviço NodePort com um Arquivo YAML

Anteriormente, a Implantação echo1 era exposta usando o comando kubectl expose e acessada internamente usando o ClusterIP. Agora, usaremos um Serviço NodePort que é uma abordagem do desenvolvedor para ter echo1 acessível externamente pela rede.

O Serviço NodePort abre uma porta específica em todos os nós e encaminha qualquer tráfego para essa porta ao Serviço.

Observação A prática padrão não recomenda o uso de NodePort para sistemas de Produção por vários motivos, principalmente o seguinte:

  1. Definir um arquivo de Serviço.

    cat << 'EOF' | tee myservice.yaml > /dev/null
    apiVersion: v1
    kind: Service
    metadata:
      name: echo1-nodeport
      namespace: default
    spec:
      ipFamilies:
      - IPv4
      ipFamilyPolicy: SingleStack
      ports:
      - nodePort: 32387
        port: 80
        protocol: TCP
        targetPort: 8080
      selector:
        app: echo1
      sessionAffinity: None
      type: NodePort
    status:
      loadBalancer: {}
    EOF
    
    • tipo: - Torna o Serviço disponível para solicitações de rede de clientes externos. Os valores válidos incluem: nodePort, LooadBalancer.
    • nodePort: - A porta externa usada para acessar o Serviço.
    • porta: - O número da porta exposto no cluster.
    • targetPort: - A Porta na qual o contêiner está fazendo listening.
  2. Crie o Serviço.

    kubectl apply -f myservice.yaml
    

    Exemplo de Saída:

    [oracle@ocne-node01 ~]$ kubectl apply -f myservice.yaml 
    service/echo1 created
    

    Observação: É comum ter as definições de Implantação e Serviço no mesmo arquivo YAML para simplificar o gerenciamento de um aplicativo. O uso de arquivos separados nessas etapas é apenas para fins de treinamento. Ao combiná-los em um único arquivo, use a sintaxe YAML --- para separá-los.

  3. Exiba como o Kubernetes armazena o Serviço recém-criado.

    kubectl get service echo1-nodeport -o yaml
    

    Exemplo de Saída:

    [oracle@ocne-node01 ~]$ kubectl get service echo1-nodeport -o yaml
    apiVersion: v1
    kind: Service
    metadata:
      annotations:
        kubectl.kubernetes.io/last-applied-configuration: |
          {"apiVersion":"v1","kind":"Service","metadata":{"annotations":{},"name":"echo1-nodeport","namespace":"default"},"spec":{"ipFamilies":["IPv4"],"ipFamilyPolicy":"SingleStack","ports":[{"nodePort":32387,"port":80,"protocol":"TCP","targetPort":8080}],"selector":{"app":"echo1"},"sessionAffinity":"None","type":"NodePort"},"status":{"loadBalancer":{}}}
      creationTimestamp: "2022-06-29T00:14:30Z"
      name: echo1-nodeport
      namespace: default
      resourceVersion: "6242"
      uid: 3171dda6-05b8-45b8-a0ba-457eab6e4f71
    spec:
      clusterIP: 10.100.17.53
      clusterIPs:
      - 10.100.17.53
      externalTrafficPolicy: Cluster
      internalTrafficPolicy: Cluster
      ipFamilies:
      - IPv4
      ipFamilyPolicy: SingleStack
      ports:
      - nodePort: 32387
        port: 80
        protocol: TCP
        targetPort: 8080
      selector:
        app: echo1
      sessionAffinity: None
      type: NodePort
    status:
      loadBalancer: {}
    
  4. Descreva o serviço Pods.

    kubectl describe svc echo1-nodeport
    

    Exemplo de Saída:

    [oracle@ocne-node01 ~]$ kubectl describe svc echo1-nodeport
    Name:                     echo1-nodeport
    Namespace:                default
    Labels:                   <none>
    Annotations:              <none>
    Selector:                 app=echo1
    Type:                     NodePort
    IP Family Policy:         SingleStack
    IP Families:              IPv4
    IP:                       10.100.17.53
    IPs:                      10.100.17.53
    Port:                     <unset>  80/TCP
    TargetPort:               8080/TCP
    NodePort:                 <unset>  32387/TCP
    Endpoints:                10.244.0.7:8080
    Session Affinity:         None
    External Traffic Policy:  Cluster
    Events:                   <none>
    
  5. Obtenha os Pontos Finais do objeto.

    Os Pontos Finais rastreiam os endereços IP dos Pods para os quais o serviço envia tráfego.

    kubectl get endpoints echo1-nodeport
    

    Exemplo de Saída:

    [oracle@ocne-node01 ~]$ kubectl get endpoints echo1-nodeport
    NAME             ENDPOINTS         AGE
    echo1-nodeport   10.244.0.7:8080   8m39s
    
  6. Liste os Pods que estão executando o aplicativo.

    kubectl get pods --output=wide
    

    Exemplo de Saída:

    [oracle@ocne-node01 ~]$ kubectl get pods -o wide
    NAME                     READY   STATUS    RESTARTS   AGE   IP           NODE          NOMINATED NODE   READINESS GATES
    echo1-7cbf6dfb96-mlds4   1/1     Running   0          80m   10.244.0.7   ocne-node01   <none>           <none>
    test-6c486b6d76-v4htj    1/1     Running   0          83m   10.244.0.6   ocne-node01   <none>           <none>
    

    O endereço IP nesta listagem de echo1 deve corresponder ao valor mostrado na etapa anterior para Pontos Finais, que é o endereço IP do Pod em execução no nó especificado.

  7. Liste os Serviços.

    kubectl get svc -o wide
    

    Exemplo de Saída:

    [oracle@ocne-node01 ~]$ kubectl get svc -o wide
    NAME                TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE   SELECTOR
    clusterip-service   ClusterIP   10.107.31.75   <none>        80/TCP         78m   app=echo1
    echo1-nodeport      NodePort    10.100.17.53   <none>        80:32387/TCP   10m   app=echo1
    kubernetes          ClusterIP   10.96.0.1      <none>        443/TCP        88m   <none>
    

    Esse comando usou a opção alternativa de -o wide, em vez de --output=wide.

    Anote o NodePort, que é definido como 32387 para o Serviço echo1-nodeport.

  8. Obtenha o endereço IP do nó.

    O ambiente de laboratório gratuito é executado em um único nó ocne-node01.

    ip -br a
    

    No ambiente de laboratório gratuito, o endereço IP deve retornar o endereço IP privado da instância de 10.0.0.140 designado à interface ens3.

  9. Use JSONPath para designar a variável NodePort.

    NODEPORT=$(kubectl get -o jsonpath="{.spec.ports[0].nodePort}" services echo1-nodeport)
    
  10. Use JSONPath para designar o IP do Nó a uma variável.

    NODES=$(kubectl get nodes -o jsonpath='{ $.items[*].status.addresses[?(@.type=="InternalIP")].address }')
    
  11. Crie uma regra de firewall.

    Essa regra permite o tráfego no node:nodeport, em que node é o endereço IP do host do sistema ou da máquina virtual em que o Pod está sendo executado.

    sudo firewall-cmd --permanent --add-port=$NODEPORT/tcp
    sudo firewall-cmd --reload
    

    Após o --reload, o daemon firewalld recarrega sua configuração, que inclui iptables. Como o kube-proxy depende do iptables, haverá um atraso na resposta dos Serviços.

  12. Use o endereço do nó e a porta do nó para verificar o aplicativo.

    curl -s $NODES:$NODEPORT
    

    Exemplo de Saída:

    [oracle@ocne-node01 ~]$ curl -s $NODES:NODEPORT
    CLIENT VALUES:
    client_address=10.244.0.1
    command=GET
    real path=/
    query=nil
    request_version=1.1
    request_uri=http://10.0.0.140:8080/
    
    SERVER VALUES:
    server_version=nginx: 1.10.0 - lua: 10001
    
    HEADERS RECEIVED:
    accept=*/*
    host=10.0.0.140:32387
    user-agent=curl/7.61.1
    BODY:
    

    A saída mostra a solicitação do roteamento do nó local por meio do Serviço NodePort, por meio do kube-proxy e do Pod que está executando a Implantação echo1.

    Observação: Se a saída parecer trava, isso se deve à recarga anterior do firewall. Digite Ctrl-C e tente novamente.

Remover Implantações e Serviços

Uma vez feito com um Serviço ou uma Implantação, remova-os do Kubernetes.

  1. Remover Serviços.

    kubectl delete svc clusterip-service echo1-nodeport
    
  2. Remova implantações.

    kubectl delete deployments echo1
    kubectl delete deploy test
    

A remoção de objetos pode ser feita individualmente ou em grupos. Verifique o Manual de Referência do Kubernetes para obter mais informações.

Resumo

Este laboratório fornece apenas o mais breve de introduções à funcionalidade que usa um Cloud-Native Orchestrator como a Kubernetes oferece a qualquer organização usando o Kubernetes para gerenciar suas implantações de Contêiner. Esses exercícios fornecem a primeira etapa do que provavelmente será uma longa jornada para a flexibilidade que o uso do Kubernetes pode oferecer.

Para Obter Mais Informações

Mais Recursos de Aprendizagem

Explore outros laboratórios em docs.oracle.com/learn ou acesse mais conteúdo de aprendizado gratuito no canal YouTube do Oracle Learning. 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.