Expose Services by using SLB

You can use SLB to access Services in a serverless cluster.

Examples

The following section uses some examples to describe how to configure and use SLB in typical scenarios to meet different needs. A Deployment must be created first.

The nginx-deployment.yaml file is as follows:

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: nginx
spec:
  replicas: 2
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx

Create an NGINX Deployment:

# kubectl apply -f nginx-deployment.yaml

Expose Services to the Internet through SLB

Use SLB to expose Services to the Internet. The simple-svc.yaml file is as follows:

apiVersion: v1
kind: Service
metadata:
  labels:
    app: nginx
  name: simple-svc
spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    app: nginx
  type: LoadBalancer

Create a Service and obtain the IP address of the Service.

# kubectl apply -f simple-svc.yaml
# kubectl get svc
NAME         TYPE           CLUSTER-IP       EXTERNAL-IP     PORT(S)        AGE
simple-svc   LoadBalancer   10.254.171.216   120.92.xx.xx   80:32733/TCP   11s

A Service named simple-svc is created and is exposed to the Internet through SLB (by setting the type parameter to LoadBalancer). The Service can be accessed through a public IP address (120.92.xx.xx). In the console, you can view a public SLB instance with the IP address of 120.92.xx.xx, bandwidth of 1 Mbit/s, and billing mode of Pay-By-Daily-Config in the SLB instance list.

SLB supports various configuration parameters. To use these parameters, annotations are required. For more information, see the "List of annotations" appendix of this topic.

Create an SLB instance that supports HTTP

In the Service configuration of Kubernetes, the Protocol field only supports TCP and UDP. To use Layer 7 load balancing, you can annotate service.beta.kubernetes.io/ksc-loadbalancer-protocol-port with the format "PROTOCOL:PORT". The value of PORT must be the same as that of port in spec:ports. The simple-svc.yaml file is as follows:

apiVersion: v1
kind: Service
metadata:
  annotations:
    service.beta.kubernetes.io/ksc-loadbalancer-protocol-port: "HTTP:80"
  labels:
    app: nginx
  name: simple-http-svc
spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    app: nginx
  type: LoadBalancer

Create an SLB instance that supports HTTPS

Apply for a certificate in the Kingsoft Cloud console, and then create an SLB instance that supports HTTPS by using the following annotations. The https-svc.yaml file is as follows:

apiVersion: v1
kind: Service
metadata:
  annotations:
    service.beta.kubernetes.io/ksc-loadbalancer-protocol-port: "HTTPS:443"
    service.beta.kubernetes.io/ksc-loadbalancer-cert-id: "your-cert-id"  
  labels:
    app: nginx
  name: https-lb
spec:
  ports:
  - port: 443
    protocol: TCP
    targetPort: 443
  selector:
    app: nginx
  type: LoadBalancer

Use an existing SLB instance

When a Service is exposed through SLB, a new SLB instance is created by default. If you do not create a new SLB instance but use an existing SLB instance, specify the ID of the existing SLB instance in the annotation. Note that if the port of the specified SLB instance is already occupied, the listener is deleted during the process of creating the Service.

Multiple Kubernetes Services can reuse the same SLB instance. The restrictions are as follows:

• If the SLB instance is automatically created by a Kubernetes Service, the SLB instance cannot be reused. Otherwise, the SLB instance will be deleted. Only an SLB instance that is created manually in the console or by calling the API can be reused.

The svc-using-existing-lb.yaml file is as follows:

apiVersion: v1
kind: Service
metadata:
  annotations:
    service.beta.kubernetes.io/ksc-loadbalancer-id: "your-lb-id"
  labels:
    app: nginx
  name: svc-using-existing-lb
spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    app: nginx
  type: LoadBalancer

Use a private SLB instance

For an internal Service that is not exposed to the Internet, you can use a private SLB instance. One way is to create an SLB instance in the console and then specify the ID of the SLB instance by using an annotation. For more information, see the "Use an existing SLB instance" section. Alternatively, specify the type of the SLB instance as internal and the ID of an endpoint subnet in annotations. Then, a new private SLB instance will be created for internal communication. The internal-svc.yaml file is as follows:

apiVersion: v1
kind: Service
metadata:
  annotations:
    service.beta.kubernetes.io/ksc-loadbalancer-type: "internal"
    service.beta.kubernetes.io/ksc-loadbalancer-subnet-id: ""your-Reserve-id"
  labels:
    app: nginx
  name: internal-svc
spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    app: nginx
  type: LoadBalancer

List of annotations

Notes:

• Do not manually delete an SLB instance that is automatically created with a Kubernetes Service.
• Do not manually change an SLB listener that is automatically created with a Kubernetes Service.