Practical Tips for Managing Xiaomi Application Engine on Xiaomi Cloud

Since its launch on Xiaomi Cloud, the Kubernetes‑based Xiaomi Application Engine has been widely adopted, and this guide presents six practical tips to make cloud‑native application management more efficient and convenient.

Explicitly Specify Image Tags for Easier Management

When building images, engineers should explicitly set a tag that includes version or other auxiliary information. Without a tag, the latest tag is used by default, causing each container start to check the registry for updates, which hampers version control and slows startup.

Two Methods to Reduce Image Size

1. Use Alpine‑based Base Images – Alpine is a minimal Linux distribution whose Docker image is only 4‑5 MB. Most languages and frameworks provide Alpine‑based images (e.g., openjdk:8-jdk-alpine, node:9-alpine, python:3-alpine, etc.), dramatically shrinking the final image.

Below is a list of common Alpine base images for various runtimes:

Java (Spring Boot): openjdk:8-jdk-alpine, openjdk:8-jre-alpine Java (Tomcat): tomcat:8.5-alpine Node.js: node:9-alpine, node:8-alpine Python: python:3-alpine, python:2-alpine PHP: php:7-fpm-alpine (add Nginx as needed)

Ruby: ruby:2-alpine Go / compiled binaries: start from an Alpine image and copy the statically‑linked binary (disable cgo with CGO_ENABLED=0)

Static sites: nginx:1-alpine 2. Consolidate Cleanup Commands in a Single Dockerfile Layer – Each Dockerfile instruction creates a new layer; installing packages and then cleaning them in separate commands leaves unnecessary layers. Combine installation and cleanup in one RUN line to keep the image lean.

Leverage Docker Layer Caching to Reduce Transfer Size

Docker caches unchanged layers locally; when a layer hasn't changed, it is not re‑uploaded to the registry. By separating large, infrequently changing dependencies from frequently changing application code, you can maximize cache reuse.

Example workflow for a Spring Boot application: unzip <path-to-app-jar>.jar -d app In the Dockerfile, copy the application into four parts: the first three layers contain stable dependencies, and the fourth layer contains the mutable source code. The final command runs the unpacked JAR.

Similar layering strategies apply to Java WAR files, Node.js npm modules, and other runtimes.

Avoid Process Managers to Ensure Healthy Application Restarts

When a container process crashes, many process managers stay alive, preventing the platform from detecting the failure and restarting the container. Launch the application directly without an extra manager.

Two Java‑Specific Optimizations

1. Use a recent Java SE 8 version (≥ 8u131) and add the following JVM options to make the application aware of container memory limits (adjust MaxRAMFraction as needed):

-XX:+UnlockExperimentalVMOptions -XX:+UseCGroupMemoryLimitForHeap -XX:MaxRAMFraction=1

2. Explicitly set heap parameters (e.g., -Xmx, -Xms) when the memory limit is known.

Data and Log Persistence Recommendations

1. Do not rely on local storage; containers are ephemeral. Store persistent data in backend services such as SDS or FDS.

2. Do not write logs to local files; instead, output to stdout or stderr so the platform can collect and process them.

By following these recommendations, users can avoid common pitfalls and fully leverage the capabilities of the new Xiaomi Application Engine for robust, efficient cloud‑native application management.