Redirect HTTP traffic to HTTPS

Deployment Platform
Related Documentation
Minimum Version
Kong Operator - 2.4
TL;DR

Attach an HTTPRoute to the HTTPS listener only, and annotate it with konghq.com/https-redirect-status-code: "301". Kong Gateway answers plain HTTP requests that match the Route with a redirect to the HTTPS URL.

Prerequisites

If you don’t have a Konnect account, you can get started quickly with our onboarding wizard.

  1. The following Konnect items are required to complete this tutorial:
    • Personal access token (PAT): Create a new personal access token by opening the Konnect PAT page and selecting Generate Token.
  2. Set the personal access token as an environment variable:

    export KONNECT_TOKEN='YOUR KONNECT TOKEN'

If you want cert-manager to issue and rotate the admission and conversion webhook certificates, install cert-manager to your cluster and enable cert-manager integration by passing the following argument while installing, in the next step:

   --set global.webhooks.options.certManager.enabled=true

If you do not enable this, the chart will generate and inject self-signed certificates automatically. We recommend enabling cert-manager to manage the lifecycle of these certificates. Kong Operator needs a certificate authority to sign the certificate for mTLS communication between the control plane and the data plane. This is handled automatically by the Helm chart. If you need to provide a custom CA certificate, refer to the certificateAuthority section in the values.yaml of the Helm chart to learn how to create and reference your own CA certificate.

Apply a KongLicense. This assumes that your license is available in ./license.json

echo "
apiVersion: configuration.konghq.com/v1alpha1
kind: KongLicense
metadata:
 name: kong-license
rawLicenseString: '$(cat ./license.json)'
" | kubectl apply -f -
kubectl create namespace kong --dry-run=client -o yaml | kubectl apply -f -
echo '
kind: KonnectAPIAuthConfiguration
apiVersion: konnect.konghq.com/v1alpha1
metadata:
  name: konnect-api-auth
  namespace: kong
spec:
  type: token
  token: "'$KONNECT_TOKEN'"
  serverURL: us.api.konghq.com
' | kubectl apply -f -
echo '
kind: KonnectGatewayControlPlane
apiVersion: konnect.konghq.com/v1alpha2
metadata:
  name: gateway-control-plane
  namespace: kong
spec:
  createControlPlaneRequest:
    name: gateway-control-plane
  konnect:
    authRef:
      name: konnect-api-auth
' | kubectl apply -f -

By default, when a Route accepts only HTTPS, Kong Gateway answers plain HTTP requests that match the Route with a 426 Upgrade Required status code. Use the konghq.com/https-redirect-status-code annotation to return a redirect status code such as 301 instead.

Create the kong namespace

Create the kong namespace in your Kubernetes cluster, which is where the demo will run:

kubectl create namespace kong --dry-run=client -o yaml | kubectl apply -f -

Create a certificate

  1. Create a self-signed certificate:

    openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout tls.key -out tls.crt -subj "/CN=demo.example.com"
  2. Create a Kubernetes Secret containing the certificate and key, and label it so Kong Operator can use it:

    kubectl create secret tls my-certificate -n kong --cert=tls.crt --key=tls.key
    kubectl label secret my-certificate -n kong konghq.com/secret="true"

Create Gateway resources

Create a Gateway with an HTTP listener on port 80 and an HTTPS listener on port 443:

echo '
apiVersion: gateway-operator.konghq.com/v2beta1
kind: GatewayConfiguration
metadata:
  name: gateway-configuration
  namespace: kong
spec:
  dataPlaneOptions:
    deployment:
      podTemplateSpec:
        spec:
          containers:
            - image: kong/kong-gateway:3.16
              name: proxy
---
apiVersion: gateway.networking.k8s.io/v1
kind: GatewayClass
metadata:
  name: gateway-class
spec:
  controllerName: konghq.com/gateway-operator
  parametersRef:
    group: gateway-operator.konghq.com
    kind: GatewayConfiguration
    name: gateway-configuration
    namespace: kong
---
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: kong
  namespace: kong
spec:
  gatewayClassName: gateway-class
  listeners:
    - name: http
      port: 80
      protocol: HTTP
    - name: https
      port: 443
      protocol: HTTPS
      hostname: demo.example.com
      tls:
        mode: Terminate
        certificateRefs:
          - group: ""
            kind: Secret
            name: my-certificate' | kubectl apply -f -

Create a Service and a Route

  1. Create a sample echo Service:

    kubectl apply -f https://developer.konghq.com/manifests/kic/echo-service.yaml -n kong
  2. Create an HTTPRoute bound to the https listener only. Add the konghq.com/https-redirect-status-code annotation:

    echo '
    apiVersion: gateway.networking.k8s.io/v1
    kind: HTTPRoute
    metadata:
      name: echo-route
      namespace: kong
      annotations:
        konghq.com/https-redirect-status-code: "301"
    spec:
      parentRefs:
        - name: kong
          sectionName: https
      hostnames:
        - demo.example.com
      rules:
        - matches:
            - path:
                type: PathPrefix
                value: /echo
          backendRefs:
            - name: echo
              kind: Service
              port: 1027' | kubectl apply -f -

Validate

  1. Get the Gateway’s external IP address:

    export PROXY_IP=$(kubectl get gateway kong -n kong -o jsonpath='{.status.addresses[0].value}')
  2. Send an HTTP request to the Route:

    curl -i --resolve demo.example.com:80:$PROXY_IP http://demo.example.com/echo

    Kong Gateway returns a 301 response with a Location header that points to the HTTPS URL:

    HTTP/1.1 301 Moved Permanently
    Location: https://demo.example.com/echo
  3. Send an HTTPS request to the Route:

    curl -ik --resolve demo.example.com:443:$PROXY_IP https://demo.example.com/echo

    The request succeeds and returns a 200 response.

Help us make these docs great!

Kong Developer docs are open source. If you find these useful and want to make them better, contribute today!