Come installare l’OCI Ingress native Controller su OKE

Nel mondo di Kubernetes, l’ingress controller è un componente chiave che consente di instradare il traffico in entrata verso il servizio appropriato all’interno di un cluster kubernetes. Funge da punto di ingresso per il traffico HTTP e HTTPS, consentendo l’esposizione dei servizi al mondo esterno.

Oracle ha annunciato il rilascio del suo nuovo controller di ingresso nativo OCI per Kubernetes. Questa soluzione è progettata per consentire agli sviluppatori e alle aziende di sfruttare appieno il potere delle applicazioni cloud native e fornire capacità di routing applictivo sfruttando l’ecosistema OCI.

Ingress Controller

Cos’è il Controller d’ Ingresso Nativo OCI?

Il Native Ingress Controller di OCI offre un piano di controllo centralizzato per il routing e il bilanciamento del carico, rendendo più semplice fornire i servizi in modo affidabile ed efficiente. È progettato per essere altamente personalizzabile, con supporto per tutte le ultime funzionalità di ingresso, come la terminazione del livello di trasporto sicurezza (TLS), il gate di prontezza dei pod, il routing basato su host e percorso2.

Vantaggi del Controller di Ingresso Nativo OCI

• Semplificazione delle operazioni e riduzione dei costi: Il controller di ingresso nativo consente di semplificare le operazioni e ridurre i costi condividendo un bilanciatore di carico OCI tra più applicazioni nel cluster Kubernetes.
• Integrazione nativa con il Load Balancer di OCI: Il native ingress controller di ingresso nativo si integra perfettamente con il bilanciatore di carico che funge da router come un’entità separata al di fuori del cluster (OKE)
• Integrazione nativa con il Web Application Firewall di OCI
• Gestione automatica dei certificati: il native ingress controller si integra anche con i certificati OCI, che consentono agli utenti di creare e gestire i certificati TLS utilizzati per abilitare il traffico HTTP sul bilanciatore del carico. Dopo la creazione, il controller di ingresso nativo lo associa automaticamente al sistema di bilanciamento del carico e si affida al servizio Certificati per ruotare automaticamente il certificato

Installazione su OKE

Prerequisiti

1. Creare un cluster OKE in OCI con CNI Virtual Native Pod Networking (il native ingress controller supporta anche il CNI di tipo Flannel ma risulta meno flessibile con questo tipo di configurazione)
2. Il controller installato su OKE avrà la necessità di eseguire le chiamate API verso OCI al fine di configurare correttamente i servizi di bilanciamento, i certificati e associare le policy WAF ad ogni endpoint. Pertanto sarà necessario creare sul servizio OCI IAM un instance principal (dynamic group + policy) che abbia i permessi corretti verso i diversi servizi. Qui puoi trovare l’elenco delle policy da applicare
3. Installare Helm sul tuo ambiente di lavoro (link)

Il codice dell’OCI Ingress Native Ingress controller è disponibile su github al seguente indirizzo:

GitHub - oracle/oci-native-ingress-controller: OCI Native Ingress Controller

Il repo contiene non solo il codice sorgente ma anche degli esempi di manifest yaml da utilizzare per la creazione degli ingress e delle custom resource definition necessarie.

Installazione del controller via Helm

1. Clona sul tuo ambiente una copia del repo che ospita l’Helm chart dell’ingress controller

git clone https://github.com/oracle/oci-native-ingress-controller

2. All’interno della directory helm edita il file values.yaml

3. Inserisci gli ocid del tuo ambiente per le seguenti risorse:

• compartment_id: ocid del comprtment dove è stato istanziato il cluster OKE
• subnet_id: ocid della subnet dove si vuole instanziare il load balancer dell’ingress
• cluster_id: ocid del cluster OKE

3. Verifica il tipo di autenticazione sempre all’interno del file values.yaml. In questo esempio si usa l’autenticazione attravero un instance principal pertanto il setting corretto è il seguente:

4. Naviga all’interno della dyrectory oci-native-ingress-controller ed esegui il comando d’installazione

helm install oci-native-ingress-controller helm/oci-native-ingress-controller

5. Verifica che i pod del controller siano RUNNING attraverso il seguente comando

kubectl get pods -n native-ingress-controller-system --selector='app.kubernetes.io/name in (oci-native-ingress-controller)' -o wide

output:

A questo punto il controller è pronto per essere utilizzato

Esponiamo un servizio attraverso l’ingress controller installato

Esponiamo adesso il servizio di un Deployment d’esempio contenuto all’interno del repo github.

1. Creiamo su OKE un namespace che ospiterà le risorse custom del controller, il service, l’ingress e il pod del servizio

kubectl create namespace echo-sam

2. Creiamo le risorse del controller inserendo all’interno del file ingress_rs.yml la definizione di:

• IngressClassParameters: custom resource definition (CRD) che definisce i parametri utilizzati per una specifica Ingress Class
• IngressClass: definizione della classe di default che verrà usata per la creazione dei miei ingress. La creazione di questa risorsa su OKE scatenerà la creazione del load balancer su OCI

apiVersion: "ingress.oraclecloud.com/v1beta1"
kind: IngressClassParameters
metadata:
  name: ingressparms-cr-test
  namespace: echo-sample-app
spec:
  compartmentId: "ocid1.compartment.oc1..aaaaaaaavns642mrw265vu6r5x4gosyhen24gxyzvbyyn4nrieaakhrtlpea"
  subnetId: "ocid1.subnet.oc1.eu-milan-1.aaaaaaaa5aspmqbjwo2bn5qrj6b3rvxhoa5ltc7lv2fetdkn47uc55ezjzwa"
  loadBalancerName: "native-ic-lb"
  isPrivate: false
  maxBandwidthMbps: 400
  minBandwidthMbps: 100

---
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  name: default-ingress-class
  annotations:
    ingressclass.kubernetes.io/is-default-class: "true"
spec:
  controller: oci.oraclecloud.com/native-ingress-controller
  parameters:
    scope: Namespace
    namespace: echo-sample-app
    apiGroup: ingress.oraclecloud.com
    kind: ingressclassparameters
    name: ingressparms-cr-test

Eseguiamo quindi il comando

kubectl apply -f ingress_rs.yml

3. A questo punto è possbile creare le risorse kubernetes che implementano:

• Deployment: creazione dei pod che implementano la mia applicazione
• Service: esposizione interna del servizio applicativo attraverso un Cluster-ip
• Ingress: risorsa che definisce le regole di esposizione del servizio e del routing applicativo verso i pod applicativi

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: testecho1
  namespace: echo-sample-app
  labels:
    app: testecho1
spec:
  minReadySeconds: 5
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 75%
  replicas: 4
  selector:
    matchLabels:
      app: testecho1
  template:
    metadata:
      labels:
        app: testecho1
    spec:
      containers:
        - name: testecho1
          image: registry.k8s.io/echoserver:1.4
          ports:
            - containerPort: 8080

---
apiVersion: v1
kind: Service
metadata:
  name: testecho1
  namespace: echo-sample-app
  annotations:
spec:
  selector:
    app: testecho1
  ports:
    - name: http-80
      protocol: TCP
      port: 80
      targetPort: 8080
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ingress-readiness
  namespace: echo-sample-app
  annotations:
    oci-native-ingress.oraclecloud.com/healthcheck-force-plaintext: "true"
    oci-native-ingress.oraclecloud.com/healthcheck-path: "/"
    oci-native-ingress.oraclecloud.com/healthcheck-port: "8080"
    oci-native-ingress.oraclecloud.com/healthcheck-protocol: "HTTP"
    oci-native-ingress.oraclecloud.com/healthcheck-return-code: "200"
spec:
  ingressClassName: default-ingress-class
  rules:
  - http:
      paths:
        - path: /testecho1
          pathType: Prefix
          backend:
            service:
              name: testecho1
              port:
                number: 80

Eseguiamo quindi il comando

kubectl apply -f deployment_sample.yml

4. Controlliamo che nel cluster le risrse sopra siano state effettivamente create e proviamo ad accedere il servizio usando l’ip del loadbalancer usando il seguente indirizzo:

http://<ip del load balancer creato dal controller>/testecho1

Output:

Conclusione

L’introduzione del controller di ingresso nativo OCI segna un passo importante per Oracle nel fornire soluzioni cloud native integrate e ottimizzate. Con la sua capacità di gestire in modo efficiente le risorse di ingresso direttamente all’interno di Kubernetes, senza fare affidamento su controller esterni, Oracle sta aprendo nuove strade per lo sviluppo e la gestione delle applicazioni cloud native.

Per maggiori informazioni e per una guida dettagliata su come configurare il controller di ingresso nativo OCI, visitate la documentazione ufficiale di Oracle.

DISCLAIMER: **DISCLAIMER**: Le opinioni e i punti di vista espressi in questo post sono esclusivamente miei e non rappresentano in alcun modo le posizioni, le strategie o le opinioni dell’organizzazione per cui lavoro o con cui sono associato. Questo post è stato scritto e pubblicato a titolo personale.