Aller au contenu
Outscale Academy

Lab 02 : Déployer et exposer une application dans OKS

Introduire les annontations

Dans cet atelier, vous allez apprendre à déployer une application simple sur Kubernetes.

Architecture du TP

Section intitulée « Architecture du TP »

Dans cette partie, vous allez apprendre à :

  • Déployer une application simple sur le cluster Kubernetes.
  • Déployer une Application Nginx et l’Exposer

Vérifier l’accès au cluster

Section intitulée « Vérifier l’accès au cluster »

Assurez-vous d’avoir les permissions nécessaires pour accéder au cluster cible. Vous devez disposer d’un utilisateur ou d’un rôle qui vous permet d’exporter ou de récupérer la configuration du cluster.

Récupérer le fichier kubeconfig

Section intitulée « Récupérer le fichier kubeconfig »
Terminal window
oks-cli cluster kubeconfig --cluster-name my-cluster --project-name my-project > kubeconfig.yaml
export KUBECONFIG=./kubeconfig.yaml

Tester le cluster

Section intitulée « Tester le cluster »
Terminal window
kubectl get nodes

Installer et Configurer NGINX Ingress dans Kubernetes

Section intitulée « Installer et Configurer NGINX Ingress dans Kubernetes »
  1. Installer le contrôleur NGINX Ingress

Option 1 : Installation via Helm

Section intitulée « Option 1 : Installation via Helm »
  1. Ajouter le dépôt de chartes NGINX Ingress :
Terminal window
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update
  1. Installer le contrôleur Ingress NGINX dans le namespace ingress-nginx :
Terminal window
helm install nginx-ingress ingress-nginx/ingress-nginx --set controller.admissionWebhooks.enabled=true --create-namespace --namespace ingress-nginx
  • Vérifier le déploiement du contrôleur Ingress
  • Vérifier que les pods du contrôleur Ingress sont en cours d’exécution :

Example de sortie:

Terminal window
kubectl get pods -n ingress-nginx
NAME                                        READY   STATUS    RESTARTS   AGE
ingress-nginx-controller-7bbfb99f87-s5cr6   1/1     Running   0          3m
  • Assurez-vous que les pods sont dans un état Running.
  • Vérifier le Service de LoadBalancer
  • Vérifiez l’adresse IP externe du LoadBalancer pour Ingress :

Exemple de sortie :

Terminal window
kubectl get svc -n ingress-nginx
NAME                                 TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)                      AGE
ingress-nginx-controller             LoadBalancer   10.96.0.1       203.0.113.10   80:30080/TCP,443:30443/TCP   5m
ingress-nginx-controller-admission   ClusterIP      10.92.97.75     <none>          443/TCP                     5m
  • Maintenant, nous pouvons déployer une application simple et l’exposer via NGINX Ingress :
---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: echoheaders
  name: service-test
  namespace: ingress-nginx
spec:
  ports:
  - port: 8080
    protocol: TCP
    targetPort: 8080
  selector:
    app: echoheaders
  type: ClusterIP
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: echoheaders
  name: echoheaders
  namespace: ingress-nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      app: echoheaders
  template:
    metadata:
      labels:
        app: echoheaders
    spec:
      containers:
      - image: gcr.io/google_containers/echoserver:1.10
        imagePullPolicy: IfNotPresent
        name: echoheaders
        ports:
        - containerPort: 8080
          protocol: TCP
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: test-ingress
  namespace: ingress-nginx
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "false"
    stz-test: "2"
spec:
  ingressClassName: nginx
  rules:
  - http:
      paths:
      - pathType: Prefix
        path: "/"
        backend:
          service:
            name: service-test
            port:
              number: 8080
    host: 'service-test.eu-west-2.lbu.outscale.com'
Terminal window
kubectl apply -f ingress.yaml
  • Vérifier que l’Ingress est déployé et fonctionnel

Exemple de sortie :

Terminal window
kubectl get ingress -n ingress-nginx
NAME           CLASS            HOSTS                                     ADDRESS       PORTS   AGE
test-ingress   internal-nginx   service-test.eu-west-2.lbu.outscale.com   80.247.7.60   80      13m
  • Tester l’accès via curl :
Terminal window
curl -H "Host: service-test.eu-west-2.lbu.outscale.com" 80.247.7.60

Si tout est ok, vous devriez voir une sortie de ce type dans votre terminal:

Terminal window
Hostname: echoheaders-65475f6b6-llqkw


Pod Information:
  -no pod information available-


Server values:
  server_version=nginx: 1.13.3 - lua: 10008


Request Information:
  client_address=X.X.X.X
  method=GET
  real path=/
  query=
  request_version=1.1
  request_scheme=http
  request_uri=http://service-test.eu-west-2.lbu.outscale.com:8080/


Request Headers:
  accept=*/*
  host=service-test.eu-west-2.lbu.outscale.com
  user-agent=curl/8.7.1
  x-forwarded-for=X.X.X.X
  x-forwarded-host=service-test.eu-west-2.lbu.outscale.com
  x-forwarded-port=443
  x-forwarded-proto=http
  x-forwarded-scheme=http
  x-real-ip=X.X.X.X
  x-request-id=897a8e2212b4db9c33e8c4e25bf50b85
  x-scheme=http


Request Body:
  -no body in request-

Maintenant, utilisons SSL. Tout d’abord, installons le cert-manager :

Terminal window
helm repo add jetstack https://charts.jetstack.io --force-update


helm install \
  cert-manager jetstack/cert-manager \
  --namespace cert-manager \
  --create-namespace \
  --version v1.19.1 \
  --set crds.enabled=true

Et appliquez les manifestes nécessaires :

Terminal window
apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt-prod
spec:
  selfSigned: {}
---
apiVersion: cert-manager.io/v1
kind: Issuer
metadata:
  name: letsencrypt-ca
  namespace: ingress-nginx
spec:
  ca:
    secretName: letsencrypt-ca
---
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: letsencrypt-ca
  namespace: ingress-nginx
spec:
  isCA: true
  commonName: osm-system
  secretName: letsencrypt-ca
  issuerRef:
    name: letsencrypt-prod
    kind: ClusterIssuer
    group: cert-manager.io

Maintenant, nous avons un certificat (auto-signé), fourni par CertManager.

Dans un premier temps, supprimer l’ingress créé préalablement

Terminal window
kubectl delete -f ingress.yaml

Remplacez l’ingress par celui contenant la définition TLS dans nouveau fichier ingress-tls.yaml:

---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: test-ingress
  namespace: ingress-nginx
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "false"
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
spec:
  tls:
    - hosts:
      - '*.eu-west-2.lbu.outscale.com'
      secretName: letsencrypt-ca
  ingressClassName: nginx
  rules:
  - http:
      paths:
      - pathType: Prefix
        path: "/"
        backend:
          service:
            name: service-test
            port:
              number: 8080
    host: 'service-test.eu-west-2.lbu.outscale.com'

Appliquez-le !

Terminal window
kubectl apply -f ingress-tls.yaml

Testons le port 80:

Terminal window
curl -H "Host: service-test.eu-west-2.lbu.outscale.com" 80.247.7.60

Testons le port 443 (HTTPS):

Terminal window
curl -H "Host: service-test.eu-west-2.lbu.outscale.com" https://80.247.7.60 -k

Conclusion

Section intitulée « Conclusion »

Une fois ces étapes complétées, vous aurez installé le contrôleur Ingress NGINX et configuré l’accès à votre application via un nom d’hôte personnalisé (my-nginx.example.com).