Configuring the Container Lifecycle

A startup command is executed when a container starts. It is used to define the main process of a container. The main process status determines the container lifecycle. If the command fails to be executed and no restart policy is configured, the container will be terminated.

By default, the default command is executed during image start. To run a specific command or rewrite the default image setting, you must perform specific operations. By default, the container executes the startup command preset in the image. Docker images contain a set of metadata fields for defining the startup behavior, including ENTRYPOINT and CMD. If the commands and arguments (specified by Command and Args) are not configured in the container specifications, the default values during image build are used.

If the commands and arguments used to run a container are configured during workload creation, the default commands ENTRYPOINT and CMD are overwritten during image build. The rules are as follows:

1. Log in to the CCE console.
2. Click the cluster name to go to the cluster console, choose Workloads in the navigation pane, and click Create Workload in the upper right corner.
3. In Container Settings, choose Container Information > Lifecycle > Startup Command and enter the command and arguments.

   Table 2 Container startup command

   Parameter	Example Value	Description	Example YAML
   Command	/bin/sh	Enter one or more executable commands. For multiple commands, place each on a separate line. NOTE: When running multiple commands, use /bin/sh or another shell as the executable, and pass the commands as arguments.	... spec: containers: - image: nginx:latest command: - /bin/sh args: - '-c ' - sleep 10 ...
   Args	-c sleep 10	Enter one or more arguments. If you need multiple arguments, separate them on different lines.

4. Configure other parameters and click Create Workload in the lower right corner. If the workload is in the Running state, the startup command is successfully executed.

A PostStart hook, a container lifecycle hook provided by Kubernetes, is used to execute initialization tasks, such as service registration and dynamic configuration generation, immediately after the main process of a container starts. This hook is asynchronously triggered by kubelet and runs in parallel with the main process. Although the PostStart hook is executed asynchronously with the main process of the container, if the PostStart hook takes too long or is suspended, the container may not change to the Running state. If the PostStart hook fails to be executed, the container may fail to start and be terminated.

1. Log in to the CCE console.
2. Click the cluster name to go to the cluster console, choose Workloads in the navigation pane, and click Create Workload in the upper right corner.
3. In Container Settings, choose Container Information > Lifecycle > Post-Start and configure parameters based on service requirements. For example:
   • If initialization logic (such as running scripts and configuring the environment) needs to be executed in the container, select CLI.
   • When external systems or services require notification, for example, registering a service or calling a Settings API, select HTTP request.

   Table 3 Post-start processing

   Processing Method	Example Value	Description	Example YAML
   CLI	Run the following commands to write the message file to the container's /usr/share directory: /bin/sh -c echo Hello from the postStart handler > /usr/share/message	Used for running the commands in the container. You need to configure Command. The command format is Command Arg[1] Arg[2]..., where Command indicates a system command or a user-defined executable program. If no path is specified, the system searches for the command in the default path. If multiple commands needed to be executed, write them into a script in the container image in advance and invoke the script using this command. The executable command must be executed synchronously or in the frontend. If it is executed asynchronously or in the backend, the lifecycle hook may fail to be executed. CAUTION: Ensure that the postStart script runs to completion and exits properly. Otherwise, subsequent pod status updates and pod deletion will be affected.	... lifecycle: postStart: exec: command: - /bin/sh - '-c' - echo Hello from the postStart handler > /usr/share/message ...
   HTTP request	Path: /nginx Port: 80 Host: 127.0.0.1	Used for initiating an HTTP request. The related parameters are described as follows: Path: (optional) request URL. Port: (mandatory) requested port. Host: (optional) requested host IP address. The default value is the IP address of the pod.	lifecycle: postStart: httpGet: path: /nginx port: 80 host: 127.0.0.1 scheme: HTTP ...

4. Configure other parameters and click Create Workload in the lower right corner. After a period of time, the workload status changes to Running.

If a container crashes or exits abnormally, the PreStop hook will not be triggered. The pod's termination grace period starts to count down before the PreStop hook is executed. Regardless of the outcome of the hook handler, the container will be terminated within the pod's termination grace period unless the finalizer delays the termination process. Other management operations on the container are blocked until the PreStop hook is complete or the termination grace period is reached.

1. Log in to the CCE console.
2. Click the cluster name to go to the cluster console, choose Workloads in the navigation pane, and click Create Workload in the upper right corner.
3. In Container Settings, choose Container Information > Lifecycle > Pre-Stop and configure parameters.

   Table 4 Pre-stop processing parameters

   Parameter	Example Value	Description	Example YAML
   CLI	Enter the following commands to gracefully stop the Nginx service: /bin/sh -c nginx -s quit; while killall -0 nginx; do sleep 1; done	Used for running the commands in the container. You need to configure Command. The command format is Command Arg[1] Arg[2]..., where Command indicates a system command or a user-defined executable program. If no path is specified, the system searches for the command in the default path. If multiple commands needed to be executed, write them into a script in the container image in advance and invoke the script using this command.	... lifecycle: preStop: exec: command: - /bin/sh - '-c' - nginx -s quit; while killall -0 nginx; do sleep 1; done ...
   HTTP request	Path: /nginx Port: 80 Host: 127.0.0.1	Used for initiating an HTTP request. The related parameters are described as follows: Path: (optional) request URL. Port: (mandatory) requested port. Host: (optional) requested host IP address. The default value is the IP address of the pod.	lifecycle: preStop: httpGet: path: /nginx port: 80 host: 127.0.0.1 scheme: HTTP ...

4. Configure other parameters and click Create Workload in the lower right corner. After a period of time, the workload status changes to Running.

1. Use kubectl to access the cluster. For details, see Accessing a Cluster Using kubectl.
2. Create a YAML file for configuring a workload. In this example, the file name is lifecycle.yaml. You can change it as needed.

   vim lifecycle.yaml
   
   

   Example file content:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: nginx
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: nginx
     template:
       metadata:
         labels:
           app: nginx
       spec:
         containers:
         - image: nginx 
            command:   # Startup command:  Pause the current process for 10 seconds.
              - /bin/sh 
            args: 
            - '-c '
            - sleep 10 
           imagePullPolicy: Always
           lifecycle:
             postStart:     # Post-start command:  Write the message file to the container's  /usr/share  directory.
               exec: 
                  command: 
                  - /bin/sh 
                    - '-c' 
                  - echo Hello from the postStart handler > /usr/share/message 
             preStop:   # Pre-stop command:  Gracefully stop the Nginx service.
                exec: 
                  command: 
                  - /bin/sh 
                    - '-c' 
                  - nginx -s quit; while killall -0 nginx; do sleep 1; done 
           name: nginx
         imagePullSecrets:
         - name: default-secret
   
   

3. Create the workload.

   kubectl create -f lifecycle.yaml
   
   

   If information similar to the following is displayed, the workload is being created:

   deployment.apps/nginx created
   
   

4. Check the workload status.

   kubectl get deployment
   
   

   If all the pods of the workload are available, the workload has been created.

   NAME     READY   UP-TO-DATE   AVAILABLE   AGE
   nginx      1/1     1            1           4m59s