Container Service for Kubernetes:Use an existing SLB instance to expose an application

Use the ACK console

1. Log on to the ACK console. In the left-side navigation pane, click Clusters.

2. On the Clusters page, find the cluster that you want to manage and click its name. In the left-side pane, choose Workloads > Deployments.

3. On the Deployments page, click Create from Image and configure the basic information, container settings, and advanced settings of the Deployment.

   1. On the Basic Information wizard page, specify Name, keep the default settings for other parameters, and click Next. In this example, the name is set to my-nginx.

   2. On the Container wizard page, specify the image name and container ports, keep the default settings for other parameters, and click Next.

      Parameter	Valid value
      Image Name	Click Select images. In the Select images and image tags dialog box, click the Artifact Center tab, search for nginx, and select the image repository named openanolis/nginx. Then, click Select Image Tag, set an image tag, and click OK.
      Port	Name: nginx. Container Port: 80.

   3. On the Advanced wizard page, keep the default settings and click Create to create an NGINX application.

Use kubectl

1. Create a file named my-nginx.yaml file and add the following YAML content to the file:

   apiVersion: apps/v1 # for versions before 1.8.0 use apps/v1beta1
   kind: Deployment
   metadata:
     name: my-nginx    # The name of the sample application. 
     labels:
       app: nginx
   spec:
     replicas: 2       # The number of replicated pods. 
     selector:
       matchLabels:
         app: nginx     # You must specify the same value in the selector of the Service that is used to expose the application. 
     template:
       metadata:
         labels:
           app: nginx
       spec:
       #  nodeSelector:
       #    env: test-team
         containers:
         - name: nginx
           image: anolis-registry.cn-zhangjiakou.cr.aliyuncs.com/openanolis/nginx:1.14.1-8.6
           ports:
           - containerPort: 80                                # The port that you want to expose in the Service.

2. Run the following command to deploy the my-nginx application:

   kubectl apply -f my-nginx.yaml

3. Run the following command to query the status of the application:

   kubectl get deployment my-nginx

   Expected output:

   NAME       READY   UP-TO-DATE   AVAILABLE   AGE
   my-nginx   2/2     2            2           50s

Use the ACK console

1. Log on to the ACK console. In the left-side navigation pane, click Clusters.

2. On the Clusters page, find the cluster that you want to manage and click its name. In the left-side pane, choose Network > Services.

3. On the Services page, click Create. In the Create Service dialog box, configure the required parameters.

   Parameter	Description	Example
   Name	The name of the Service.	my-nginx-svc
   Service Type	Specify Service Type. You can create the following types of Services to handle access from different types of sources: Cluster IP A ClusterIP Service. This type of Service is used for communication within the cluster. Only ClusterIP Services can discover and communicate with each other. If you select Headless Service, you can interact with other service discovery mechanisms without the need to rely on the ClusterIP-based service discovery and load balancing features provided by Kubernetes by default. SLB. Note The new page for creating Services is in canary release. To use the new version, submit a ticket. SLB allows you to create LoadBalancer Services to expose applications in a cluster by using CLB instances or NLB instances. Compared with NodePort Services, the availability and performance of applications exposed by using LoadBalancer Services are greatly improved. Supported SLB instances: CLB: For more information, see CLB. NLB: For more information, see NLB. Node Port A NodePort Service. External users can access this type of Services by using the IP address and specified port of a node. You can connect to a NodePort Service through <NodeIP>:<NodePort>. However, you must manually configure load balancing.	Select SLB. Click Use Existing Resource and select a CLB instance from the drop-down list. The CLB instance in this example is newly created. You must configure listeners for the CLB instance. Therefore, select Overwrite Existing Listeners.
   External Traffic Policy	The External Traffic Policy parameter is available only if you set the Service Type parameter to Node Port or Server Load Balancer. For more information about external traffic policies, see the Differences between external traffic policies section of the "Getting started" topic. Valid values: Local: routs traffic only to the pods of the current node. Cluster: routes traffic to pods on other nodes in the cluster.	Local
   Backend	The backend application that you want to associate with the Service. If you do not select a backend application, no Endpoint objects are created. For more information, see Services-without-selectors.	Name: app. Value: my-nginx.
   Port Mapping	The Service port and container port. The Service port corresponds to the port field in the YAML file and the container port corresponds to the targetPort field in the YAML file. The container port must be the same as the port that is exposed in the backend pod.	80
   Annotations	The annotations to be added to the Service to configure the SLB instance. For more information, see Use annotations to configure CLB instances and Use annotations to configure NLB instances. Important Do not reuse the SLB instance of the API server in the cluster. Otherwise, cluster access failures may occur.	In this example, two annotations are added to specify the pay-by-bandwidth billing method and set the maximum bandwidth to 2 Mbit/s to limit the amount of traffic that flows through the Service. Example: service.beta.kubernetes.io/alibaba-cloud-loadbalancer-charge-type:paybybandwidth service.beta.kubernetes.io/alibaba-cloud-loadbalancer-bandwidth:2
   Label	The label to be added to the Service, which identifies the Service.	None

   Click OK.

4. On the Services page, click the name of the Service to go to the details page. In the Basic Information section, click the External Endpoint of the Service, such as 39.106.XX.XX:80, to access the application.

Use kubectl

1. Create a Service.

   Create a file named my-nginx-svc.yaml and add the following content to the file.

   • Replace ${YOUR_LB_ID} in service.beta.kubernetes.io/alibaba-cloud-loadbalancer-id with the ID of the SLB instance that you created in the SLB console.

   • If you use an existing SLB instance, no listeners are created for the SLB instance and the existing listeners of the SLB instance are not overridden by default. To override the listeners, set service.beta.kubernetes.io/alibaba-cloud-loadbalancer-force-override-listeners to "true". In this example, the annotation is set to true to create listeners for the SLB instance because the SLB instance is newly created. For more information about annotations, see Use annotations to configure CLB instances and Use annotations to configure NLB instances.

   • Set selector to the value of matchLabels in the my-nginx.yaml file, which is app: nginx. This way, the Service is associated with the backend pod.

   apiVersion: v1
   kind: Service # Define a Service. 
   metadata:
     annotations:
       service.beta.kubernetes.io/alibaba-cloud-loadbalancer-id: ${YOUR_LB_ID}
       service.beta.kubernetes.io/alicloud-loadbalancer-force-override-listeners: 'true'
     labels:
       app: nginx
     name: my-nginx-svc
     namespace: default
   spec:
     ports:
     - port: 80
       protocol: TCP
       targetPort: 80
     selector:
       app: nginx
     type: LoadBalancer

   Parameter	Description
   kind	Specifies that the resource object is a Service.
   metadata	Defines the basic information about the Service, such as the name, labels, and namespace.
   metadata.annotations	You can add LoadBalancer annotations. In this example, the annotation service.beta.kubernetes.io/alibaba-cloud-loadbalancer-address-type is set to intranet, which specifies that the Service is accessible over the internal network. For more information, see Use annotations to configure CLB instances.
   spec.selector	Defines the label selector of the Service. The Service exposes the pods whose labels match the label selector.
   spec.ports.port	Specifies the Service port that is exposed with the cluster IP address. You can access the Service from within the cluster by sending requests to clusterIP:port.
   spec.ports.targetPort	Specifies the port of the backend pod to receive traffic. The traffic that flows through the Service port is forwarded by kube-proxy to the port (specified by targetPort) of the backend pod and then reaches the containers.
   spec.type	Defines how the Service is accessed. LoadBalancer: The Service is exposed by using an SLB instance. When no SLB instance is specified for the Service, an Internet-facing SLB instance is created by default. You can set the annotation to intranet to create an internal-facing SLB instance to expose the Service to internal access. For more information, see Use annotations to configure CLB instances and Use annotations to configure NLB instances. ClusterIP: exposes the Service within the cluster. A ClusterIP Service is accessible from within the cluster. NodePort: maps a node port to the backend Service. You can access the Service from outside the cluster by sending requests to NodeIP:NodePort. ExternalName: maps the Service to a DNS server.

2. Run the following command to create a Service named my-nginx-svc and use the Service to expose the application:

   kubectl apply -f my-nginx-svc.yaml

3. Run the following command to confirm that the LoadBalancer Service is created:

   kubectl get svc my-nginx-svc

   Expected output:

   NAME           TYPE           CLUSTER-IP    EXTERNAL-IP      PORT(S)        AGE
   my-nginx-svc   LoadBalancer   172.21.5.82   39.106.XX.XX     80:30471/TCP   5m

4. Run the following command to access the application:

   curl <YOUR-External-IP> # Replace <YOUR-External-IP> with the external IP address that you obtained in the preceding step.

   Expected output:

   <!DOCTYPE html>
   <html>
   <head>
   <title>Welcome to nginx!</title>
   <style>
       body {
           width: 35em;
           margin: 0 auto;
           font-family: Tahoma, Verdana, Arial, sans-serif;
       }
   </style>
   </head>
   <body>
   <h1>Welcome to nginx!</h1>
   <p>If you see this page, the nginx web server is successfully installed and
   working. Further configuration is required.</p>
   
   <p>For online documentation and support please refer to
   <a href="http://nginx.org/">nginx.org</a>.<br/>
   Commercial support is available at
   <a href="http://nginx.com/">nginx.com</a>.</p>
   
   <p><em>Thank you for using nginx.</em></p>
   </body>
   </html>

Use the ACK console

1. Log on to the ACK console. In the left-side navigation pane, click Clusters.

2. On the Clusters page, find the cluster that you want to manage and click its name. In the left-side pane, choose Network > Services.

3. On the Services page, you can click a Service to view details or click Update or Delete in the Actions column of the Service to update or delete the Service.

Use kubectl

Update a Service

• Method 1: Run the following command to update a Service:

  kubectl edit service my-nginx-svc

• Method 2: Manually delete a Service, modify the YAML file, and then recreate the Service.

  kubectl apply -f my-nginx-svc.yaml

View a Service

Run the following command to view a Service:

kubectl get service my-nginx-svc

Expected output:

NAME           TYPE           CLUSTER-IP    EXTERNAL-IP      PORT(S)        AGE
my-nginx-svc   LoadBalancer   172.21.XX.XX   192.168.XX.XX     80:31599/TCP   5m

Delete a Service

kubectl delete service my-nginx-svc