4.5. Routage externe et entrant

Procédure

1. Créez un service Knative qui contient l'étiquette ou l'annotation que vous souhaitez propager à la route OpenShift Container Platform :

   • Pour créer un service en utilisant YAML :

     Exemple de service créé à l'aide de YAML

     apiVersion: serving.knative.dev/v1
     kind: Service
     metadata:
       name: <service_name>
       labels:
         <label_name>: <label_value>
       annotations:
         <annotation_name>: <annotation_value>
     ...

   • Pour créer un service en utilisant le CLI Knative (kn), entrez :

     Exemple de service créé à l'aide d'une commande kn

     $ kn service create <service_name> \
       --image=<image> \
       --annotation <annotation_name>=<annotation_value> \
       --label <label_value>=<label_value>

2. Vérifiez que la route OpenShift Container Platform a été créée avec l'annotation ou l'étiquette que vous avez ajoutée en inspectant la sortie de la commande suivante :

   Exemple de commande de vérification

   $ oc get routes.route.openshift.io \
        -l serving.knative.openshift.io/ingressName=<service_name> \ 1
        -l serving.knative.openshift.io/ingressNamespace=<service_namespace> \ 2
        -n knative-serving-ingress -o yaml \
            | grep -e "<label_name>: \"<label_value>\""  -e "<annotation_name>: <annotation_value>" 3

   1

   Utilisez le nom de votre service.

   2

   Utilisez l'espace de noms dans lequel votre service a été créé.

   3

   Utilisez vos valeurs pour les noms et valeurs de l'étiquette et de l'annotation.

Procédure

1. Créer un service Knative qui inclut l'annotation serving.knative.openshift.io/disableRoute=true:

   Important

   L'annotation serving.knative.openshift.io/disableRoute=true indique à OpenShift Serverless de ne pas créer automatiquement une route pour vous. Cependant, le service affiche toujours une URL et atteint un statut de Ready. Cette URL ne fonctionne pas en externe jusqu'à ce que vous créiez votre propre route avec le même nom d'hôte que le nom d'hôte dans l'URL.

   1. Créer une ressource Knative Service:

      Exemple de ressource

      apiVersion: serving.knative.dev/v1
      kind: Service
      metadata:
        name: <service_name>
        annotations:
          serving.knative.openshift.io/disableRoute: "true"
      spec:
        template:
          spec:
            containers:
            - image: <image>
      ...

   2. Appliquer la ressource Service:

      $ oc apply -f <filename>

   3. Facultatif. Créez un service Knative à l'aide de la commande kn service create:

      Exemple de commande kn

      $ kn service create <service_name> \
        --image=gcr.io/knative-samples/helloworld-go \
        --annotation serving.knative.openshift.io/disableRoute=true

2. Vérifiez qu'aucune route OpenShift Container Platform n'a été créée pour le service :

   Example command

   $ $ oc get routes.route.openshift.io \
     -l serving.knative.openshift.io/ingressName=$KSERVICE_NAME \
     -l serving.knative.openshift.io/ingressNamespace=$KSERVICE_NAMESPACE \
     -n knative-serving-ingress

   Vous obtiendrez le résultat suivant :

   No resources found in knative-serving-ingress namespace.

3. Créer une ressource Route dans l'espace de noms knative-serving-ingress:

   apiVersion: route.openshift.io/v1
   kind: Route
   metadata:
     annotations:
       haproxy.router.openshift.io/timeout: 600s 1
     name: <route_name> 2
     namespace: knative-serving-ingress 3
   spec:
     host: <service_host> 4
     port:
       targetPort: http2
     to:
       kind: Service
       name: kourier
       weight: 100
     tls:
       insecureEdgeTerminationPolicy: Allow
       termination: edge 5
       key: |-
         -----BEGIN PRIVATE KEY-----
         [...]
         -----END PRIVATE KEY-----
       certificate: |-
         -----BEGIN CERTIFICATE-----
         [...]
         -----END CERTIFICATE-----
       caCertificate: |-
         -----BEGIN CERTIFICATE-----
         [...]
         -----END CERTIFICATE----
     wildcardPolicy: None

   1

   La valeur du délai d'attente pour la route OpenShift Container Platform. Vous devez définir la même valeur que le paramètre max-revision-timeout-seconds (600s par défaut).

   2

   Le nom de la route OpenShift Container Platform.

   3

   L'espace de noms pour la route OpenShift Container Platform. Il doit s'agir de knative-serving-ingress.

   4

   Le nom d'hôte pour l'accès externe. Vous pouvez le définir sur <service_name>-<service_namespace>.<domain>.

   5

   Les certificats que vous souhaitez utiliser. Actuellement, seule la terminaison edge est prise en charge.

4. Appliquer la ressource Route:

   $ oc apply -f <filename>

Procédure

1. Déployer les certificats de serveur dans l'espace de noms knative-serving-ingress:

   $ export san="knative"

   Note

   La validation du nom alternatif du sujet (SAN) est nécessaire pour que ces certificats puissent transmettre la demande à <app_name>.<namespace>.svc.cluster.local.

2. Générer une clé racine et un certificat :

   $ openssl req -x509 -sha256 -nodes -days 365 -newkey rsa:2048 \
       -subj '/O=Example/CN=Example' \
       -keyout ca.key \
       -out ca.crt

3. Générer une clé de serveur qui utilise la validation SAN :

   $ openssl req -out tls.csr -newkey rsa:2048 -nodes -keyout tls.key \
     -subj "/CN=Example/O=Example" \
     -addext "subjectAltName = DNS:$san"

4. Créer des certificats de serveur :

   $ openssl x509 -req -extfile <(printf "subjectAltName=DNS:$san") \
     -days 365 -in tls.csr \
     -CA ca.crt -CAkey ca.key -CAcreateserial -out tls.crt

5. Configurez un secret pour la passerelle locale de Kourier :

   1. Déployer un secret dans l'espace de noms knative-serving-ingress à partir des certificats créés lors des étapes précédentes :

      $ oc create -n knative-serving-ingress secret tls server-certs \
          --key=tls.key \
          --cert=tls.crt --dry-run=client -o yaml | oc apply -f -

   2. Mettre à jour la spécification de la ressource personnalisée (CR) KnativeServing pour utiliser le secret créé par la passerelle Kourier :

      Exemple KnativeServing CR

      ...
      spec:
        config:
          kourier:
            cluster-cert-secret: server-certs
      ...

Procédure

1. Ajoutez l'annotation serverless.openshift.io/default-enable-http2=true à la ressource personnalisée KnativeServing:

   oc annotate knativeserving <your_knative_CR> -n knative-serving serverless.openshift.io/default-enable-http2=true

2. Après l'ajout de l'annotation, vous pouvez vérifier que la valeur appProtocol du service Kourier est h2c:

   $ oc get svc -n knative-serving-ingress kourier -o jsonpath="{.spec.ports[0].appProtocol}"

   Exemple de sortie

   h2c

3. Vous pouvez désormais utiliser le cadre gRPC sur le protocole HTTP/2 pour le trafic externe, par exemple :

   import "google.golang.org/grpc"
   
   grpc.Dial(
      YOUR_URL, 1
      grpc.WithTransportCredentials(insecure.NewCredentials())), 2
   )

   1

   Votre URL ksvc.

   2

   Votre certificat.

Procédure

1. Trouvez l'hôte de l'application. Voir les instructions dans Verifying your serverless application deployment.

2. Recherchez l'adresse publique de la passerelle d'entrée :

   $ oc -n knative-serving-ingress get svc kourier

   Exemple de sortie

   NAME                   TYPE           CLUSTER-IP      EXTERNAL-IP                                                             PORT(S)                                                                                                                                      AGE
   kourier   LoadBalancer   172.30.51.103   a83e86291bcdd11e993af02b7a65e514-33544245.us-east-1.elb.amazonaws.com   80:31380/TCP,443:31390/TCP   67m

   L'adresse publique apparaît dans le champ EXTERNAL-IP et, dans ce cas, il s'agit de a83e86291bcdd11e993af02b7a65e514-33544245.us-east-1.elb.amazonaws.com.

3. Définissez manuellement l'en-tête host de votre requête HTTP sur l'hôte de l'application, mais dirigez la requête elle-même vers l'adresse publique de la passerelle d'entrée.

   $ curl -H "Host: hello-default.example.com" a83e86291bcdd11e993af02b7a65e514-33544245.us-east-1.elb.amazonaws.com

   Exemple de sortie

   Hello Serverless!

   Vous pouvez également effectuer une requête gRPC directe auprès de la passerelle d'entrée :

   import "google.golang.org/grpc"
   
   grpc.Dial(
       "a83e86291bcdd11e993af02b7a65e514-33544245.us-east-1.elb.amazonaws.com:80",
       grpc.WithAuthority("hello-default.example.com:80"),
       grpc.WithInsecure(),
   )

   Note

   Veillez à ajouter le port correspondant, 80 par défaut, aux deux hôtes, comme indiqué dans l'exemple précédent.