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>
     ...

     Copy to Clipboard Toggle word wrap

   • 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>

     Copy to Clipboard Toggle word wrap

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

   Copy to Clipboard Toggle word wrap

   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>
      ...

      Copy to Clipboard Toggle word wrap

   2. Appliquer la ressource Service:

      $ oc apply -f <filename>

      Copy to Clipboard Toggle word wrap

   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

      Copy to Clipboard Toggle word wrap

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

   Copy to Clipboard Toggle word wrap

   Vous obtiendrez le résultat suivant :

   No resources found in knative-serving-ingress namespace.

   Copy to Clipboard Toggle word wrap

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

   Copy to Clipboard Toggle word wrap

   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>

   Copy to Clipboard Toggle word wrap

Procédure

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

   $ export san="knative"

   Copy to Clipboard Toggle word wrap
   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

   Copy to Clipboard Toggle word wrap

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"

   Copy to Clipboard Toggle word wrap

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

   Copy to Clipboard Toggle word wrap

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 -

      Copy to Clipboard Toggle word wrap

   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
      ...

      Copy to Clipboard Toggle word wrap

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

   Copy to Clipboard Toggle word wrap

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}"

   Copy to Clipboard Toggle word wrap

   Exemple de sortie

   h2c

   Copy to Clipboard Toggle word wrap

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

   
   )

   Copy to Clipboard Toggle word wrap

   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

   Copy to Clipboard Toggle word wrap

   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

   Copy to Clipboard Toggle word wrap

   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

   Copy to Clipboard Toggle word wrap

   Exemple de sortie

   Hello Serverless!

   Copy to Clipboard Toggle word wrap

   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(),
   )

   Copy to Clipboard Toggle word wrap
   Note

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