Configurar o Controlador de Entrada Nativo do OCI no OCI Kubernetes Engine com Nós Virtuais

Introdução

Este tutorial apresenta o processo de configuração do controlador de entrada nativo da Oracle Cloud Infrastructure (OCI) no Oracle Cloud Infrastructure Kubernetes Engine (OKE) com um pool de nós virtuais. Os nós virtuais são diferentes dos nós de trabalho regulares baseados em instância porque são uma solução sem servidor que abstrai as instâncias de computação subjacentes. Ao contrário dos nós de trabalho tradicionais, que dependem de instâncias de máquina virtual específicas, os nós virtuais são dimensionados dinamicamente com base nas demandas de carga de trabalho e não exigem gerenciamento manual da infraestrutura subjacente. Isso os torna ideais para cargas de trabalho que precisam de dimensionamento automático e redução da sobrecarga operacional.

Neste tutorial, vamos configurar o controlador de entrada nativo do OCI no OKE usando nós virtuais. Vamos configurar políticas de identidade da carga de trabalho, ativar o complemento de entrada e implantar recursos de entrada com manifestos do Kubernetes.

Ao seguir essas tarefas, você pode expor seus aplicativos e gerenciar o tráfego de entrada usando os recursos do OCI Load Balancer, tudo isso aproveitando a simplicidade operacional dos nós virtuais. Essa configuração simplifica o gerenciamento de tráfego e dá suporte a cargas de trabalho de nível de produção de maneira escalável e econômica.

Objetivos

Configure o controlador de entrada nativo do OCI no OKE para gerenciar recursos de entrada com eficiência.

Tarefa 1: Criar Política do Controlador de Identidades da Carga de Trabalho

Antes de ativar o controlador de entrada nativo do OCI, crie uma política de controlador de identidades de carga de trabalho. Os nós virtuais não têm servidor e não usam instâncias do OCI Compute, portanto, exigem identidade de carga de trabalho em vez de controladores de instância. Esta política permite que o controlador de entrada gerencie recursos no seu compartimento.

Vá para a Console do OCI, navegue até Identidade e Segurança, Identidade e clique em Políticas.
Crie uma política e informe um nome para ela. Para obter mais informações, consulte Criar uma Política usando a Console do OCI.

Clique em Mostrar editor manual e informe as instruções de política a seguir, substituindo o location e o cluster-ocid pelos valores específicos.

Observação:

<location> deve ser substituído pelo compartimento no qual seus recursos estão localizados.

<cluster-ocid> deve ser substituído pelo OCID do seu cluster do OKE.

Allow any-user to manage load-balancers in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to use virtual-network-family in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to manage cabundles in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to manage cabundle-associations in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to manage leaf-certificates in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to read leaf-certificate-bundles in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to manage leaf-certificate-versions in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to manage certificate-associations in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to read certificate-authorities in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to manage certificate-authority-associations in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to read certificate-authority-bundles in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to read public-ips in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to manage floating-ips in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to manage waf-family in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to read cluster-family in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to use tag-namespaces in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Tarefa 2: Ativar Complemento do Controlador de Entrada Nativa do OCI

Quando a política de controlador de identidades de carga de trabalho necessária estiver em vigor, você poderá continuar a ativar o complemento do controlador de entrada nativo do OCI para seu cluster do OKE. Esse complemento permite o uso de um Balanceador de Carga do OCI para gerenciar o tráfego de entrada com eficiência.

Navegue até o cluster do OKE na Console do OCI.
Role para baixo e clique em Add-ons.
Na página Complementos, clique em Controlador de Entrada Nativo.
Na página Editar Controlador de Entrada Nativo, selecione Ativar Controlador de Entrada Nativo e especifique as seguintes informações em Opção.
- compartmentId: Informe o OCID do seu compartimento.
- loadBalancerSubnetId: Informe o OCID da sub-rede do balanceador de carga.
- authType: Digite workloadIdentity.
Clique em Salvar alterações para aplicar as definições.

Observação: Essa configuração é necessária para pools de nós virtuais, como mencionado anteriormente, eles não têm servidor e não suportam autenticação do controlador de instâncias. A identidade da carga de trabalho é o método de autenticação suportado neste caso.

Tarefa 3: Implantar Recursos de Entrada para Ativar a Funcionalidade de Entrada Nativa

Nesta tarefa, crie os recursos necessários do Kubernetes para ativar a funcionalidade de entrada usando o controlador de entrada nativo do OCI. Isso inclui o IngressClassParameters, IngressClass e o objeto Ingress real.

Revise a finalidade de cada recurso.
- IngressClassParameters: Especifica a configuração específica do OCI, como OCID do compartimento, sub-rede e largura de banda.
- IngressClass: Vincula a funcionalidade de entrada do Kubernetes ao controlador de entrada do OCI.
- Entrada: Define como o tráfego é roteado para seus serviços.
Substitua os valores de espaço reservado no YAML.
- Substitua <your compartment ocid> pelo OCID do Compartimento real.
- Substitua <your load balancer subnet ocid> pelo OCID da sub-rede do seu Balanceador de Carga.

Aplique o manifesto YAML. Salve o código YAML a seguir em um arquivo, por exemplo, native-ingress.yaml.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test-web-app
  namespace: default
spec:
  replicas: 2
  selector:
    matchLabels:
      app: test-web
  template:
    metadata:
      labels:
        app: test-web
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80
        readinessProbe:
          httpGet:
            path: /
            port: 80
          initialDelaySeconds: 3
          periodSeconds: 5
        resources:
          requests:
            cpu: "100m"
            memory: "128Mi"
          limits:
            cpu: "500m"
            memory: "256Mi"

apiVersion: v1
kind: Service
metadata:
  name: test-web-service
  namespace: default
spec:
  selector:
    app: test-web
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80

apiVersion: ingress.oraclecloud.com/v1beta1
kind: IngressClassParameters
metadata:
  name: native-ic-params
  namespace: native-ingress-controller-system
spec:
  compartmentId: "ocid1.compartment.oc1..aaaaaaaa2eimxxxxxxxxxxz4lkcety52hfdg6wdoff6744yn4hrshofla"
  subnetId: "ocid1.subnet.oc1.iad.aaaaaaaaa72ie4xxxxxxxxxrxxrly6nmkb77qxt6mi2t5pvrdhge32q"
  loadBalancerName: "test-web-ingress"
  isPrivate: false
  maxBandwidthMbps: 400
  minBandwidthMbps: 100

apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  name: native-ic-ingress-class
  annotations:
    ingressclass.kubernetes.io/is-default-class: "true"
spec:
  controller: oci.oraclecloud.com/native-ingress-controller
  parameters:
    apiGroup: ingress.oraclecloud.com
    kind: IngressClassParameters
    name: native-ic-params
    scope: Namespace
    namespace: native-ingress-controller-system

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: test-web-ingress-quickstart
  namespace: default
  annotations:
    oci.oraclecloud.com/load-balancer-type: "lb"
    oci.oraclecloud.com/healthcheck-protocol: "HTTP"
    oci.oraclecloud.com/healthcheck-port: "80"
    oci.oraclecloud.com/healthcheck-path: "/"
    oci.oraclecloud.com/healthcheck-return-code: "200"
spec:
  ingressClassName: native-ic-ingress-class
  rules:
  - host: test.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: test-web-service
            port:
              number: 80
  - http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: test-web-service
            port:
              number: 80

Execute o comando a seguir para aplicar o manifesto.
```
kubectl apply -f native-ingress.yaml
```

Verifique a criação do recurso.

kubectl get ingressclassparameters
kubectl get ingressclass
kubectl get ingress

Tarefa 4: Testar o Balanceador de Carga do Controlador de Entrada Nativo do OCI

Observação: Certifique-se de que as portas necessárias (por exemplo, 80 e/ou 443) estejam abertas na Lista de Segurança da VCN e/ou no Grupo de Segurança de Rede (NSG) antes de testar o endereço IP do Balanceador de Carga do OCI.

Para verificar se o controlador de entrada nativo do OCI está funcionando corretamente, siga estas etapas:

Use kubectl para recuperar o endereço IP do recurso de entrada.
```
kubectl get ingress
```
Copie o endereço IP mostrado na saída.
Abra o Web browser e cole o endereço IP na barra de endereços.
Se a configuração estiver correta, você deverá ver a resposta padrão do serviço implantado.

Você também pode verificar se o Balanceador de Carga do OCI foi criado corretamente na Console do OCI navegando até o menu de navegação, selecionando Networking e clicando em Load Balancer.

Próximas Etapas

Com este tutorial, você configurou com sucesso o controlador de entrada nativo no OKE usando nós virtuais. Essa configuração permite gerenciar o tráfego de entrada com o serviço OCI Load Balancer enquanto se beneficia da escalabilidade e da simplicidade de um ambiente Kubernetes sem servidor. Agora você está pronto para implementar cargas de trabalho de nível de produção com gerenciamento de tráfego simplificado e sobrecarga mínima de infraestrutura.

Confirmações

Autor – JP Santana (Arquiteto Mestre em Nuvem)

Mais Recursos de Aprendizado

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

Set Up the OCI Native Ingress Controller on OCI Kubernetes Engine with Virtual Nodes

G34289-03