Create Configure Knative Networking page

docs/snippets/dns.md

@@ -1,20 +1,11 @@
-You can configure DNS to prevent the need to run curl commands with a host header.
+<!-- Referenced by:
+- install/operator/knative-with-operators.md
+- install/yaml-install/serving/install-serving-with-yaml.md
+-->
+Knative provides a Kubernetes Job called `default-domain` that configures Knative Serving to use [sslip.io](http://sslip.io) as the default DNS suffix.
 
-The following tabs expand to show instructions for configuring DNS.
-Follow the procedure for the DNS of your choice:
+```bash
+kubectl apply -f {{artifact(repo="serving",file="serving-default-domain.yaml")}}
+```
 
-=== "Magic DNS (sslip.io)"
-
-    Knative provides a Kubernetes Job called `default-domain` that configures Knative Serving to use [sslip.io](http://sslip.io) as the default DNS suffix.
-
-    ```bash
-    kubectl apply -f {{artifact(repo="serving",file="serving-default-domain.yaml")}}
-    ```
-
-    !!! warning
-        This will only work if the cluster `LoadBalancer` Service exposes an
-        IPv4 address or hostname, so it will not work with IPv6 clusters or local setups
-        like minikube unless [`minikube tunnel`](https://minikube.sigs.k8s.io/docs/commands/tunnel/)
-        is running.
-
-        In these cases, see the "Real DNS" or "No DNS" tabs.
+This configuration works only if the cluster `LoadBalancer` Service exposes an IPv4 address or hostname. It does not work with IPv6 clusters or local setups such as minikube unless the [`minikube tunnel`](https://minikube.sigs.k8s.io/docs/commands/tunnel/) is running.

docs/snippets/netadapter-contour.md

@@ -0,0 +1,31 @@
+<!-- Referenced by:
+- install/yaml-install/serving/install-serving-with-yaml.md
+-->
+Use the following steps to install and enable Contour and set it as the ingress controller.
+
+1. Install the Knative Contour configuration:
+
+    ```bash
+    kubectl apply -f {{ artifact(repo="net-contour",org="knative-extensions",file="contour.yaml")}}
+    ```
+
+1. Install the Knative Contour integration controller:
+
+    ```bash
+    kubectl apply -f {{ artifact(repo="net-contour",org="knative-extensions",file="net-contour.yaml")}}
+    ```
+
+1. Configure Knative Serving to use Contour:
+
+    ```bash
+        kubectl patch configmap/config-network \
+        --namespace knative-serving \
+        --type merge \
+        --patch '{"data":{"ingress-class":"contour.ingress.networking.knative.dev"}}'
+    ```
+
+1. Get the external IP address (FQDN) to later configure DNS:
+
+    ```bash
+    kubectl --namespace contour-external get service envoy
+    ```

docs/snippets/netadapter-gatewayapi.md

@@ -0,0 +1,58 @@
+<!-- Referenced by:
+- install/yaml-install/serving/install-serving-with-yaml.md
+-->
+Use the following steps to install and configure the Knative Gateway API adapter.  Note that you need to have a [Gateway API implementation](https://gateway-api.sigs.k8s.io/implementations/) installed in your cluster.  The Knative team currently tests the Istio, Contour, and Envoy-Gateway implementations of Gateway API.
+
+1. Install the Knative Gateway API:
+
+    ```bash
+      kubectl apply -f {{ artifact(repo="net-gateway-api",org="knative-extensions",file="net-gateway-api.yaml") }}
+    ```
+
+    Alternatively, you can also install a preconfigured Gateways for either Contour or Istio. Replace the filename in this step with either `contour-gateway.yaml` or `istio-gateway.yaml`. If you use either file  you can skip the next step to configure gateway resources.
+
+1. Configure Gateway resources for use by external ("north-south") Knative traffic, and local ("east-west") traffic. If you do not need separate routing for local traffic (or [private Knative services](../../../serving/services/private-services.md)), you can use the external Gateway for both.
+
+    Knative verifies traffic settings according to the Kubernetes namespace, the name of the Gateways, and an underlying DNS name such as a Kubernetes service DNS name that corresponds to the Gateway.
+
+    ```bash
+    cat <<EOF | kubectl apply -f -
+    apiVersion: v1
+    kind: ConfigMap
+    metadata:
+      name: config-gateway
+      namespace: knative-serving
+    data:
+      external-gateways: |
+        - name: knative-ingress-gateway  # Name of the external Gateway resource
+          namespace: knative-serving     # Namespace where the Gateway is deployed
+          service: knative-ingress-service.knative-serving.svc.cluster.local  # backing Service FQDN
+      local-gateways: |
+        - name: knative-local-gateway    # Name of the local Gateway resource
+          namespace: knative-serving     # Namespace where the Gateway is deployed
+          service: knative-local-service.knative-serving.svc.cluster.local    # backing Service FQDN
+    EOF
+    ```
+
+1. Configure Knative Serving to use the Knative Gateway API ingress class:
+
+    ```bash
+    kubectl patch configmap/config-network \
+      --namespace knative-serving \
+      --type merge \
+      --patch '{"data":{"ingress-class":"gateway-api.ingress.networking.knative.dev"}}'
+    ```
+
+1. Verify the `config-gateway` ConfigMap:
+
+    ```bash
+    kubectl get configmap config-gateway -n knative-serving -o yaml
+    ```
+
+1. Get the external IP address (FQDN) to configure DNS records:
+
+    ```bash
+    kubectl get gateway --all-namespaces
+    ```
+
+    Look for the external Gateway (`knative-ingress-gateway`) to get status and address for DNS configuration.

docs/snippets/netadapter-istio.md

@@ -0,0 +1,32 @@
+<!-- Referenced by:
+- install/yaml-install/serving/install-serving-with-yaml.md
+-->
+Use the following steps to install Istio and set it as the ingress controller.
+
+1. Install a properly configured Istio:
+
+    ```bash
+    kubectl apply -l knative.dev/crd-install=true -f {{ artifact(repo="net-istio",org="knative-extensions",file="istio.yaml") }}
+    kubectl apply -f {{ artifact(repo="net-istio",org="knative-extensions",file="istio.yaml") }}
+    ```
+
+1. Install the Knative Istio controller:
+
+    ```bash
+    kubectl apply -f {{ artifact(repo="net-istio",org="knative-extensions", file="net-istio.yaml") }}
+    ```
+
+1. Configure the `config-network` ConfigMap to use Istio:
+
+    ```bash
+        kubectl patch configmap/config-network \
+        --namespace knative-serving \
+        --type merge \
+        --patch '{"data":{"ingress-class":"istio.ingress.networking.knative.dev"}}'
+    ```
+
+1. Get the external IP address (FQDN) to later configure DNS:
+
+    ```bash
+    kubectl --namespace istio-system get service istio-ingressgateway
+    ```

docs/snippets/netadapter-kourier.md

@@ -0,0 +1,25 @@
+<!-- Referenced by:
+- install/yaml-install/serving/install-serving-with-yaml.md
+-->
+Use the following steps to install Kourier and set it as the ingress controller.
+
+1. Install the Knative Kourier controller:
+
+    ```bash
+        kubectl apply -f {{ artifact(repo="net-kourier",org="knative-extensions", file="kourier.yaml") }}
+    ```
+
+1. Configure Knative Serving to use Kourier by default:
+
+    ```bash
+    kubectl patch configmap/config-network \
+    --namespace knative-serving \
+    --type merge \
+    --patch '{"data":{"ingress-class":"kourier.ingress.networking.knative.dev"}}'
+    ```
+
+1. Get the external IP address (FQDN) to later configure DNS:
+
+    ```bash
+    kubectl --namespace kourier-system get service kourier
+    ```

docs/snippets/no-dns.md

@@ -2,40 +2,42 @@
 - install/operator/knative-with-operators.md
 - install/yaml-install/serving/install-serving-with-yaml.md
 -->
-=== "No DNS"
-
-    If you are using `curl` to access [the sample applications](/docs/getting-started/first-service/), or your own Knative app, and are unable to use the "Magic DNS (sslip.io)" or "Real DNS" methods, there is a temporary approach. This is useful for those who wish to evaluate Knative without altering their DNS configuration, as per the "Real DNS" method, or cannot use the "Magic DNS" method due to using,
-    for example, minikube locally or IPv6 clusters.
-
-    To access your application using `curl` using this method:
-
-    1. Configure Knative to use a domain reachable from outside the cluster:
-      ```bash
-      kubectl patch configmap/config-domain \
-            --namespace knative-serving \
-            --type merge \
-            --patch '{"data":{"example.com":""}}'
-      ```
-
-    1. After starting your application, get the URL of your application:
-      ```bash
-      kubectl get ksvc
-      ```
-      The output should be similar to:
-      ```bash
-      NAME            URL                                        LATESTCREATED         LATESTREADY           READY   REASON
-      helloworld-go   http://helloworld-go.default.example.com   helloworld-go-vqjlf   helloworld-go-vqjlf   True
-      ```
-
-    1. Instruct `curl` to connect to the External IP or CNAME defined by the
-       networking layer mentioned in section 3, and use the `-H "Host:"` command-line
-       option to specify the Knative application's host name.
-       For example, if the networking layer defines your External IP and port to be `http://192.168.39.228:32198` and you wish to access the `helloworld-go` application mentioned earlier, use:
-       ```bash
-       curl -H "Host: helloworld-go.default.example.com" http://192.168.39.228:32198
-       ```
-       In the case of the provided `helloworld-go` sample application, using the default configuration, the output is:
-       ```
-       Hello Go Sample v1!
-       ```
-       Refer to the "Real DNS" method for a permanent solution.
+If you are using `curl` to access [the sample applications](/docs/getting-started/first-service/), or your own Knative app, and are unable to use the "Magic DNS (sslip.io)" or "Real DNS" methods, you can evaluate Knative without altering your DNS configuration. You might have this need if minikube locally or IPv6 clusters.
+
+To access your application using `curl` using this method:
+
+1. Configure Knative to use a domain reachable from outside the cluster:
+
+  ```bash
+  kubectl patch configmap/config-domain \
+        --namespace knative-serving \
+        --type merge \
+        --patch '{"data":{"example.com":""}}'
+  ```
+
+1. After starting your application, get the URL of your application:
+
+  ```bash
+  kubectl get ksvc
+  ```
+
+  The output should be similar to:
+
+  ```bash
+  NAME            URL                                        LATESTCREATED         LATESTREADY           READY   REASON
+  helloworld-go   http://helloworld-go.default.example.com   helloworld-go-vqjlf   helloworld-go-vqjlf   True
+  ```
+
+1. Instruct `curl` to connect to the External IP or CNAME defined by the networking layer mentioned in section 3, and use the `-H "Host:"` command-line option to specify the Knative application's host name. For example, if the networking layer defines your External IP and port to be `http://192.168.39.228:32198` and you wish to access the `helloworld-go` application mentioned earlier, use:
+
+    ```bash
+    curl -H "Host: helloworld-go.default.example.com" http://192.168.39.228:32198
+    ```
+
+    In the case of the provided `helloworld-go` sample application, using the default configuration, the output is:
+
+    ```bash
+    Hello Go Sample v1!
+    ```
+
+    Refer to the "Real DNS" method for a permanent solution.

docs/snippets/real-dns-yaml.md

@@ -1,30 +1,28 @@
-=== "Real DNS"
+<!-- Referenced by:
+- install/yaml-install/serving/install-serving-with-yaml.md
+-->
+To configure DNS for Knative, take the External IP
+or CNAME from setting up networking, and configure it with your DNS provider as
+follows:
 
-    To configure DNS for Knative, take the External IP
-    or CNAME from setting up networking, and configure it with your DNS provider as
-    follows:
+- If the networking layer produced an External IP address, then configure a wildcard `A` record for the domain. In the following example, `knative.example.com` is the domain suffix for a cluster.
 
-    - If the networking layer produced an External IP address, then configure a
-      wildcard `A` record for the domain:
+    ```bash
+    *.knative.example.com == A 35.233.41.212
+    ```
 
-        ```
-        # Here knative.example.com is the domain suffix for your cluster
-        *.knative.example.com == A 35.233.41.212
-        ```
+- If the networking layer produced a CNAME, then configure a CNAME record for the domain. In the following example, `knative.example.com` is the domain suffix for a cluster.
 
-    - If the networking layer produced a CNAME, then configure a CNAME record for the domain:
+    ```bash
+    *.knative.example.com == CNAME a317a278525d111e89f272a164fd35fb-1510370581.eu-central-1.elb.amazonaws.com
+    ```
 
-        ```
-        # Here knative.example.com is the domain suffix for your cluster
-        *.knative.example.com == CNAME a317a278525d111e89f272a164fd35fb-1510370581.eu-central-1.elb.amazonaws.com
-        ```
+- After your DNS provider has been configured, direct Knative to use that domain:
 
-    - Once your DNS provider has been configured, direct Knative to use that domain:
-
-        ```yaml
-        # Replace knative.example.com with your domain suffix
-        kubectl patch configmap/config-domain \
-          --namespace knative-serving \
-          --type merge \
-          --patch '{"data":{"knative.example.com":""}}'
-        ```
+    ```yaml
+    # Replace knative.example.com with your domain suffix
+    kubectl patch configmap/config-domain \
+      --namespace knative-serving \
+      --type merge \
+      --patch '{"data":{"knative.example.com":""}}'
+    ```

docs/versioned/.nav.yml

@@ -267,7 +267,8 @@ nav:
         - Configure high-availability components: serving/config-ha.md
         - Exclude namespaces from the Knative webhook: serving/webhook-customizations.md
         - Networking Options:
-          - Configure the ingress gateway: serving/setting-up-custom-ingress-gateway.md
+          - Configure Knative networking: serving/config-network-adapters.md
+          - Configure Istio's ingress gateway: serving/setting-up-custom-ingress-gateway.md
           - Configure domain names: serving/using-a-custom-domain.md
           - Istio Authorization: serving/istio-authorization.md
           - Extending Queue Proxy image with QPOptions: serving/queue-extensions.md