Container Service for Kubernetes:Use ACK to quickly deploy a magic cube game application

Deploy and expose the application

This section shows how to create a Deployment for the ACK-Cube game and expose it to the internet using a Service. For the full list of Deployment parameters, see Create a stateless application by using a Deployment.

1. On the Clusters page, click the name of your cluster (for example, ACK-Demo).

2. In the left navigation pane, choose Workloads > Deployments.

3. In the upper-right corner, click Create from Image.

4. On the Basic Information tab, set the application name to ack-cube.

5. Click Next. On the Container tab, set the following parameters:

   Parameter	Description	Example value
   Image Name	The container image to deploy.	registry.cn-hangzhou.aliyuncs.com/acr-toolkit/ack-cube:1.0
   Resource Limit	The maximum CPU and memory the application can consume.	CPU: 1 Core, Memory: 1024 MiB. Leave Ephemeral Storage blank.
   Required Resources	The CPU and memory reserved for the application.	CPU: 0.5 Core, Memory: 512 MiB. Leave Ephemeral Storage blank.
   Port	The container port settings.	Name: ack-cube, Container Port: 80, Protocol: TCP

   

6. Click Next. On the Advanced tab, click Create in the Services section. In the Create Service dialog box, set the following parameters and click OK.

   Parameter	Description	Example value
   Name	The name of the Service.	ack-cube-svc
   Type	How the Service is accessed.	Select Server Load Balancer > Classic Load Balancer (CLB) > Create Resource. Keep the default CLB settings for this test environment.
   Port	The Service port and container port. The container port must match the backend Pod.	Service Port: 80, Container Port: 80, Protocol: TCP

   

7. Click Create. A success page appears with the application's objects listed. Click View Details to review them.

   

Access the application

Log on to the ACK consoleACK consoleACK consoleACK console. On the Clusters page, click your cluster name. In the left navigation pane, choose Workloads > Deployments. Find the ack-cube application in the default namespace. Click the Access Method tab, find the ack-cube-svc Service, and click the link in the External Endpoint column to open the Rubik's cube game.

Connect to the cluster

Connect to your ACK cluster using one of the following methods:

CloudShell

CloudShell provides a browser-based Linux environment with pre-installed tools at no cost. When CloudShell starts, it provisions a Linux virtual machine for you. You can use it with the CloudShell Web IDE to manage your cloud resources.

Log on to the ACK consoleACK consoleACK consoleACK console. In the left navigation pane, click your target cluster. On the Cluster Information page, choose Basic Information > Open Cloud Shell. After a few seconds, the CloudShell interface starts and kubectl is ready to use. For more information, see Use kubectl on Workbench or Cloud Shell to connect to ACK clusters.

Workbench

Workbench is a browser-based remote connection tool that requires no additional software installation.

Log on to the ACK consoleACK consoleACK consoleACK console. In the left navigation pane, click your target cluster. On the Cluster Information page, choose Basic Information > Manage Clusters Using Workbench. After a few seconds, the Workbench interface starts. For more information, see Connect to an instance by using Workbench.

kubectl client

Use a local kubectl client to connect over the internet.

1. Install and set up kubectl.

2. Log on to the ACK consoleACK consoleACK consoleACK console. Click your cluster name (for example, ACK-Demo). On the Cluster Information page, click the Connection Information tab. Copy the credentials from the Public Access tab and paste them into $HOME/.kube/config. Create the .kube directory and config file if they don't already exist. For more information, see Obtain the kubeconfig file of a cluster and use kubectl to connect to the cluster.

3. Run the following command to verify the connection:

   kubectl get namespace

   Expected output:

   NAME              STATUS   AGE
   arms-prom         Active   4h39m
   default           Active   4h39m
   kube-node-lease   Active   4h39m
   kube-public       Active   4h39m
   kube-system       Active   4h39m

Deploy and expose the application

This section explains how to use kubectl to deploy a stateless workload (a Deployment) in your ACK cluster and expose it by using a Service of the LoadBalancer type. All examples use YAML manifests applied with kubectl apply. The Deployment runs two replicas of ACK-Cube, and the Service exposes it via a LoadBalancer type that automatically provisions a Server Load Balancer (SLB) instance. For more information about exposing applications, see Use an automatically created SLB instance to expose an application.

1. Create a file named ack-cube.yaml with the following content:

   apiVersion: apps/v1 # for versions before 1.8.0 use apps/v1beta1
   kind: Deployment
   metadata:
     name: ack-cube # The name of the application.
     labels:
       app: ack-cube
   spec:
     replicas: 2 # The number of replicated pods.
     selector:
       matchLabels:
         app: ack-cube  # You must specify the same value for the selector of the Service that is used to expose the application.
     template:
       metadata:
         labels:
           app: ack-cube
       spec:
         containers:
         - name: ack-cube
           image: registry.cn-hangzhou.aliyuncs.com/acr-toolkit/ack-cube:1.0 # Replace with the address of the image that you want to use in the <image_name:tags> format.
           ports:
           - containerPort: 80 # The container port that you want to expose.
           resources:
             limits: # The resource limits.
               cpu: '1'
               memory: 1Gi
             requests: # The resource requests.
               cpu: 500m
               memory: 512Mi

2. Deploy the application:

   kubectl apply -f ack-cube.yaml

3. Verify that the Deployment is running:

   kubectl get deployment ack-cube

   Expected output:

   NAME       READY   UP-TO-DATE   AVAILABLE   AGE
   ack-cube   2/2     2            2           96s

4. Create a file named ack-cube-svc.yaml with the following content. The selector value must match the matchLabels value in ack-cube.yaml (app: ack-cube) to associate the Service with the backend application.

   apiVersion: v1
   kind: Service
   metadata:
     labels:
       app: ack-cube
     name: ack-cube-svc
     namespace: default
   spec:
     ports:
     - port: 80
       protocol: TCP
       targetPort: 80
     selector:
       app: ack-cube # You must specify the value of the matchLabels parameter in the YAML file that is used to create the Deployment.
     type: LoadBalancer

5. Create the Service to expose the application. Creating a LoadBalancer Service automatically provisions a public-facing SLB instance.

   kubectl apply -f ack-cube-svc.yaml

6. Confirm the Service is running and get the public IP address. This may take a minute while the SLB instance is provisioned.

   kubectl get svc ack-cube-svc

   Expected output:

   NAME           TYPE           CLUSTER-IP      EXTERNAL-IP     PORT(S)        AGE
   ack-cube-svc   LoadBalancer   172.16.72.161   47.94.xx.xx   80:31547/TCP   32s

7. Enter the EXTERNAL-IP address (for example, 47.94.xx.xx) in your browser to access the Rubik's cube game.