Learn how to create a complete Helm chart for deploying the Ghost blogging platform on Kubernetes, covering chart scaffolding, templating with values, handling multiple environments, ingress version compatibility, persistence, customizations, and sharing the chart via a GitHub Pages repository.
This tutorial walks readers through the evolution of web deployment, explains core Kubernetes concepts, and provides step‑by‑step instructions for using kubectl to create Ingress, Service, and Deployment resources that run a multi‑instance Node.js backend, culminating in a functional K8S deployment workflow.
This tutorial walks through creating a complete Helm chart for the Ghost blogging platform, covering chart scaffolding, templating with Go templates, handling multiple environments, version‑compatible Ingress, persistence, custom update strategies, and publishing the chart via a GitHub Pages repository.
This article provides an in‑depth overview of Kafka, covering why messaging systems are needed, core concepts, cluster architecture, performance optimizations such as sequential disk writes and zero‑copy, resource planning, deployment steps, configuration details, operational tools, and advanced topics like custom partitioners and time‑wheel scheduling.
This article introduces the fully open‑source HC Community IoT platform built with Vue + ElementUI on the front end and Spring Boot on the back end, and provides step‑by‑step deployment instructions, code snippets, screenshots, and the source‑code repository link.
nginxWebUI is a web‑based graphical interface that simplifies configuring, managing, and deploying Nginx—including HTTP/TCP forwarding, reverse proxy, load balancing, SSL certificate automation, and multi‑server cluster support—while providing Docker images and detailed installation steps for Linux, Windows, and macOS environments.
This article details the motivation, technology selection, architecture design, and multi‑stage performance optimization of a server‑side rendering (SSR) solution built with Vue and Nuxt for the 360 Search Encyclopedia mobile project, covering challenges, experiments, deployment strategies, and final conclusions.
This guide walks you through packaging a Spring Boot application into a Docker image with Jib, installing the Spring Boot Operator on a Kubernetes cluster, deploying a demo app, customizing deployments, handling graceful shutdown, and using node affinity for advanced scheduling.
Eris is an open-source, enterprise-level frontend scaffolding framework from Yidianzixun that streamlines project initialization, template management, development, building, and deployment through unified commands, supporting both React and Vue templates, customizable themes, and an interactive CLI to accelerate large-scale web application development.
This article provides a concise overview of Kubernetes, covering its master‑node architecture, core components, deployment workflow, pod fundamentals, container orchestration patterns, scaling and rolling updates, as well as internal and external service networking mechanisms.
The article outlines how MNN Workbench, Alibaba’s open‑source edge‑AI platform, integrates professional training capabilities, cloud‑based PAI‑DLC resources, multi‑window debugging, and visual Git Flow to streamline end‑to‑end model development, deployment, and iteration for developers of varying expertise.
The article explains how Huawei Cloud Stack leverages a modular, high‑cohesion low‑coupling architecture and an automated deployment platform to replicate a full‑stack cloud environment in a data center within a day, dramatically reducing construction time, labor costs, and ensuring sustainable, scalable digital transformation for enterprises.
This article details Alibaba’s experience building and deploying Flutter‑Web pages for the ICBU seller platform, covering version selection, code reuse, build optimization, deployment workflow, debugging, native JS integration, performance tuning, and compatibility fixes across various H5 containers.
This guide provides a comprehensive overview of the Tars microservice framework, covering its core concepts, deployment methods across various environments, configuration management, service discovery, logging, monitoring, and operational features such as gray releases and circuit‑breaker strategies.
The article explains common release strategies—including blue‑green deployment, rolling updates, canary (gray) releases, and A/B testing—detailing their principles, advantages, limitations, and practical considerations for safely delivering new versions in production environments.
This article explains how to implement graceful shutdown and startup for SpringBoot microservices using Dubbo, including unregistering services, timed waits, kill signals, JVM tuning, health checks, and deployment strategies such as rolling and blue‑green releases.
This article explains micro‑frontend architecture, its benefits over monolithic frontends, the challenges of parent/child integration, and practical implementation approaches on AWS, including web‑component and module‑based integration with code examples and deployment considerations.
The article describes the “小得物” gray‑release environment—a single‑region, isolated production setup that adds dedicated SLBs and DLB routing, uses UID‑based user and staff segmentation via HTTP headers and message metadata, and enables daytime partial‑traffic releases for the online customer‑service system, dramatically improving stability and reducing incident rates.
This article provides complete Kubernetes YAML manifests for deploying Grafana as a core Deployment and exposing it via a Service in the kube-system namespace, detailing container images, resource limits, environment variables, health probes, and persistent storage configuration.
This article explains how to use Maven profiles and the maven‑assembly‑plugin to create environment‑specific zip packages for a Spring Boot application and provides a reusable shell script (shenniu_publish.sh) for extracting, starting, stopping, and managing the deployed JAR on Linux.
This guide explains the technical stack, deployment steps, and core features of the open‑source wx‑manage system for managing multiple WeChat public accounts, including backend setup, database initialization, and frontend launch.
This step‑by‑step guide shows how to prepare a VM, clone the open‑source Mall project, build Docker images for its dependencies, push them to Alibaba Cloud Container Registry, configure Serverless Devs, and finally deploy both the backend and Vue‑based frontend to Alibaba Cloud Function Compute, including log inspection and verification.
This guide walks through cloning the Node-RED source, installing dependencies, building and running it locally on Windows, packaging the project, and then installing Node and deploying the packaged Node-RED on an offline server.
This guide demonstrates how to automate the installation, configuration, and service management of Nginx across multiple hosts using Ansible roles, detailing environment setup, directory structure, task definitions, and execution commands.
This article introduces Dootask, an open‑source task management tool offering document collaboration, mind maps, flowcharts, project management, instant messaging and file handling, built with Vue, Element‑UI and ECharts, and provides step‑by‑step Docker/Docker‑Compose deployment instructions.
This article introduces three common release strategies—blue‑green deployment, rolling deployment, and canary (gray) deployment—explaining their workflows, advantages, drawbacks, and practical considerations for safely updating production systems during iterative project releases.
This tutorial walks you through preparing three identical VMs, installing required packages, configuring Rook and Ceph versions, deploying the storage cluster on a Kubernetes 1.20 environment, exposing the Ceph dashboard, and cleaning up the installation, complete with command examples and troubleshooting tips.
This article explains common deployment strategies—including blue‑green, rolling, canary (gray) releases, and A/B testing—detailing their principles, advantages, drawbacks, and practical considerations for safely delivering new versions in production environments.
This article compares key deployment strategies—blue‑green, rolling, canary (gray) releases, and A/B testing—explaining their workflows, advantages, limitations, and practical considerations such as risk mitigation, resource usage, rollback challenges, and infrastructure requirements for modern software projects.
This guide walks through migrating a Java application to a Kubernetes platform, covering image creation, pod controllers, data persistence, service exposure, ingress publishing, and a complete step‑by‑step example with Docker, Harbor, and YAML manifests.
This article examines the hidden pitfalls of technology optimism, the inevitable vendor lock‑in of serverless platforms, and how to apply timeless architectural principles—such as abstraction, service layers, and token‑based authentication—to design portable, testable, and maintainable serverless applications across Azure and AWS.
This article compares PyInstaller and Nuitka for converting Python projects into standalone executables, highlighting Nuitka's dramatically smaller file size, faster build times, and better performance while also providing step‑by‑step installation and usage instructions.
The latest Modern.js release adds Windows platform support, provides ready‑to‑use deployment capabilities—including built‑in web server, CDN upload to Alibaba Cloud OSS or Tencent COS, and static hosting—and outlines usage examples, configuration steps, changelog details, and upgrade guidance.
This guide explains how to efficiently deploy a React frontend to a private server by either uploading the compiled build folder or pushing source code to a bare Git repository, then using a post‑receive hook to automatically build, package, and serve the application with Nginx.
This step‑by‑step guide shows how to initialize a CentOS 7 host, disable firewalls, configure time sync, prepare storage disks, pull the official Ceph Docker image, and launch MON, OSD, MGR, RGW, and MDS containers to build a functional single‑node Ceph cluster with a dashboard.
This tutorial walks through Kubernetes architecture, cluster setup methods, and a step‑by‑step Redis deployment using Pods, Deployments, StatefulSets, and an Operator SDK example, illustrating core concepts and practical commands for building reliable cloud‑native applications.
This guide explains how to efficiently deploy a React project to a private server by describing two CI/CD approaches—deploying compiled files or the source code—setting up a bare Git repository with a post‑receive hook, configuring Nginx for static serving, and pushing code from the client to trigger automatic build and deployment.
The article explains four major software release strategies—blue‑green deployment, rolling release, canary (gray) release, and A/B testing—detailing their principles, advantages, drawbacks, and practical considerations for safely rolling out new versions in production environments.
This guide explains the fundamentals of Kubernetes ReplicaSet and Deployment controllers, their specifications, how to write YAML manifests, and provides step‑by‑step command‑line examples for creating, scaling, updating, and rolling back applications in a cluster.
The article explains processing diagrams that focus on deployable code and configuration units, detailing how to group application components into deployment units, their interactions, capacity considerations, and illustrates these concepts using UML/BPMN EAP profiles and Archimate diagrams.
This guide explains how to install and configure Subversion (SVN) on a CentOS server, create a repository, set up authentication, connect clients, and implement a post‑commit hook that automatically updates the web directory, enabling code editing from devices like an iPad.
Over the last year since its 1.0 release, Deno has secured $4.9 million seed funding, formed a company, launched the Deno Deploy (a free cloud hosting service with specific request, CPU, memory, and size limits), and continues to evolve as an MIT‑licensed alternative to Node.js.
This tutorial walks through checking a Kubernetes cluster, creating a namespace with Istio sidecar injection, deploying the Bookinfo sample application, applying Istio gateway resources, and verifying services and endpoints using kubectl commands.
This tutorial walks you through creating a complete music‑streaming site using Vue.js for the front‑end and Spring Boot/MyBatis for the back‑end, covering core features, required resources, configuration, and deployment commands in a clear, practical manner.
This tutorial introduces Knative, explains its architecture and core components, and provides a detailed, image‑rich walkthrough for deploying Knative on Alibaba Cloud, testing a sample serverless application, and managing the cluster via CloudShell.
This guide walks through installing Redis, MariaDB, Go, configuring Open-Falcon's backend and frontend components, setting up Python virtual environments, and launching the monitoring system, providing complete command-line instructions and configuration details for a functional deployment.
This guide explains RocketMQ's four core components, details its architecture, walks through configuring and starting the NameServer and Broker, and provides troubleshooting steps for common startup problems, all illustrated with commands and diagrams.
This step‑by‑step guide shows how to set up Docker on CentOS 7, install Docker Compose, pull a Tomcat image, create a Spring Boot project, package it, and run it inside a Docker container using both Tomcat and OpenJDK images.
This guide details the preparation of three Linux servers, installation and configuration of JDK, Elasticsearch, Kibana, Filebeat, and Logstash, creation of necessary users and directories, and the commands to start each component, culminating in a functional ELK logging platform.
The article explains how Google’s continuous delivery practices—such as modular architecture, feature flags, gray‑scale deployments, rapid feedback loops, and a culture of always‑ready‑to‑deploy—enable faster, safer software releases while reducing risk and cost.
This guide walks through deploying Kong and its UI Konga on Kubernetes, covering configuration of PostgreSQL, handling common initialization errors, correcting environment variables, and ensuring successful startup with detailed YAML and Docker commands.
This article explains what object storage services are, introduces MinIO as a compatible, high‑performance open‑source alternative to AWS S3, and provides step‑by‑step guidance for single‑node and distributed deployments using Docker on various operating systems.
This article introduces Loki, a lightweight log aggregation system for Kubernetes, explains its background and motivations, details its simple architecture and core components (Distributor, Ingester, Querier), discusses scalability and storage options, and provides step‑by‑step deployment instructions with example YAML and shell commands.
This article explains how a Kubernetes nginx‑ingress pod acts as a gateway, converting Ingress YAML definitions into Nginx reverse‑proxy settings, detailing host‑level and pod‑level configurations, deployment manifests, service exposure, and scaling considerations.
This tutorial walks you through deploying a complete captcha labeling and recognition solution, covering Vue front‑end setup, Java back‑end packaging, and Python CNN model serving with Flask, complete with code snippets, configuration details, and deployment screenshots.
This article introduces a front‑back separated HR management system built with SpringBoot and Vue, detailing its technology stack—including Redis and RabbitMQ—and provides a quick deployment guide with code snippets, enabling developers to set up and extend the project efficiently.
The article walks through diagnosing why a second Kubernetes cluster ignored the upload‑size setting, shows how to inspect the nginx‑ingress‑controller deployment, identify the --configmap argument, and fix the issue by updating the referenced ConfigMap name to nginx‑configuration.
This article details the full migration of a large‑scale mobile app from React Native 0.51 to 0.62, covering background, major improvements such as Hermes engine adoption, extensive performance testing, risk‑controlled batch rollout, API compatibility handling, tooling support, CI/CD integration, and post‑deployment verification.
This article explains Kubernetes core concepts—including pods as container groups, how ReplicaSets maintain desired replica counts, Deployment's rolling update mechanism, and StatefulSet's approach to managing stateful services with persistent storage—providing a comprehensive guide for cloud‑native deployments.
This guide explains how to migrate classic web frameworks such as Bottle and Flask to Alibaba Cloud Function Compute using request integration, custom runtimes, and Serverless Devs, providing step‑by‑step code examples, deployment configurations, and alternative solutions for other FaaS platforms.
Learn how to create a feature‑rich, SEO‑friendly documentation website using VuePress and the Vdoing theme, covering installation, configuration, theme customization, content structuring, deployment, and tips for managing both structured and fragmented articles.
iQIYI’s mobile backend employs dogfooding‑driven gray releases with cloud‑controlled traffic, gray‑tag propagation, comprehensive front‑end and back‑end metrics, device white‑lists, and downstream service integration, allowing internal users to quickly verify code and configuration changes and catch issues before full production rollout.
This article shares a developer’s journey from spending on domains and servers to mastering deployment, covering domain registration, DNS configuration, SSL, Linux commands, server panels, and how to monetize the skills while offering a step‑by‑step guide for newcomers to use a server effectively.
This article explains how Facebook engineered a massive‑scale continuous delivery pipeline—evolving from manual cherry‑pick releases to a near‑continuous deployment system that safely pushes hundreds of code changes per hour to both web and mobile users worldwide.
If you’ve just mastered Python basics and want a hands‑on project, the article recommends starting with web development by deploying ten diverse open‑source applications—ranging from a novel platform and forum to e‑commerce, file manager, wiki, and games—providing links, star counts, languages, and setup tips to guide beginners through real‑world coding challenges.
This article explains the fundamental principles of Kubernetes core components—including pods, their networking and storage mechanisms, the role of ReplicaSets for scaling, how Deployments enable rolling updates, and how StatefulSets manage stateful services—providing clear insights and visual diagrams for each concept.
This guide explains the relationship between Pods and controllers, introduces Kubernetes Deployments for managing stateless applications, and provides a complete YAML example to create a Tomcat Deployment with three replicas and a NodePort Service, followed by the kubectl command to apply the configuration.
This article explains Kubernetes controllers, the relationship between pods and controllers, deployment use cases, YAML file handling, and provides step‑by‑step kubectl commands for creating, exposing, scaling, upgrading, and rolling back deployments in a cloud‑native environment.
This article recounts the author’s experience building a simple Java web application for a university anniversary, covering planning, environment setup, documentation, database design, coding challenges with Spring Boot, Redis, and session handling, deployment on Alibaba Cloud, and the lessons learned about architecture, logging, and monitoring.
This article reviews Redis 6.0 and 5.0 new features, compares cluster, master‑replica, and read‑write separation architectures, explains proxy and direct connection modes, and provides Java code for custom connection pools, helping you select the optimal Redis deployment for your workload.
This guide walks through automating a Go project's build, handling private repository credentials, and deploying the compiled binary to a remote server using a Jenkins pipeline, covering project structure, build steps, credential management, and a complete pipeline script.
The article examines how Walmart’s Sam’s Club in China tackles rapid release cycles, user‑experience demands, and massive resource consumption by adopting Tencent Cloud Serverless SCF’s default‑alias gray‑release strategy, highlighting its technical advantages and real‑world e‑commerce use cases.
This guide explains why a Kubernetes pod can remain in ContainerCreating due to an RBD volume still being used, walks through identifying the holding node with Ceph commands, and provides forced unmount and mountinfo techniques to resolve the issue.
This article walks through setting up GitLab CI to automatically build a Spring Boot JAR, create Docker images for Java 8 and Java 11, push them to a private registry, and deploy them to a server, covering required Dockerfiles, .gitlab-ci.yml configuration, environment files, and necessary GitLab variables.
This guide walks through setting up a Prometheus monitoring stack and Grafana visualization on a test Kubernetes cluster, covering pod inspection, directory preparation, YAML deployments for node-exporter, RBAC, ConfigMap, Prometheus and Grafana, and final service exposure.
This article details a practical smooth‑release process for a cloud‑office system, explains how to use Nginx health‑check endpoints to take instances offline, and presents three AB‑testing routing strategies—IP‑based, cookie‑based, and AB‑cluster proxy—complete with configuration examples, pros and cons, and deployment steps.
The article explains the concept of gray release, outlines a basic architecture with strategy configuration, execution, and service registry components, describes common traffic-splitting strategies, and details practical implementations using Nginx, gateway services, and complex scenarios involving data synchronization and message queues.
This article introduces Apache Kafka’s KRaft (Kafka Raft) mode, explains its architectural differences from ZooKeeper‑based deployments, details essential configuration parameters, and provides a complete step‑by‑step procedure—including commands and utility tools—to set up and operate a KRaft cluster.
This tutorial walks through creating a Flask‑based search engine powered by Elasticsearch, covering configuration files, logging setup, blueprint routing, pagination, detail views, and deployment options using Flask‑Script and Gunicorn, with complete code examples and a GitHub reference.
The article describes Luban, a scalable build management platform that provides generic, extensible packaging, template‑based configuration, automatic and manual trigger mechanisms, result storage, and integrated release capabilities to support continuous delivery of multiple mobile applications within Zhuanzhuan.
This article explains why internet products need a gray release system, outlines its basic architecture, describes common gray release strategies, and shows how to implement them using Nginx, gateway services, and database handling for complex deployment scenarios.
This article details a four‑stage migration project that rebuilt international services on a cloud‑native stack, introducing temporary Istio monitoring, standardized change processes, Helm‑based deployments, and full microservice integration while sharing practical quality‑assurance lessons and pitfalls.
This article explains how to shrink large Spring Boot fat JARs and microservice deployment packages by separating dependencies into a shared lib directory, using Maven plugins and manifest configuration across four progressive levels, ultimately achieving kilobyte‑scale business JARs and faster deployments.
This article explains how to use Maven profiles to manage multiple Spring Boot environments, configure the maven‑assembly‑plugin to create a zip release containing the jar, configuration files and a custom shell script, and then deploy and control the application on Linux using the provided shenniu_publish.sh tool.
This article provides a comprehensive tutorial on installing UCloud's free USDP version for private big‑data deployments, covering environment preparation, minimum node specifications, resource download, configuration files, one‑click initialization scripts, server startup, web UI access, license acquisition, and optional manual setup procedures.
This comprehensive guide walks beginners through Kubernetes fundamentals, explaining the architecture, core objects such as Pods, Deployments, Services, and Ingress, and provides step‑by‑step instructions for configuring kubectl, deploying resources, managing updates, and troubleshooting common issues.
This article demystifies Kubernetes by explaining its core scheduling function, the role of Pods, YAML configuration, probes, high‑availability constructs like ReplicaSet and Deployment, internal components, resource limits, and practical cluster‑setup tools, providing a comprehensive guide for newcomers and practitioners alike.
This article explains how to package a Spring Boot application using Maven's assembly plugin, configure environment-specific profiles, and deploy the resulting zip with a custom shell script that supports start, stop, restart, and unzip operations on Linux.
This article demystifies Kubernetes by explaining its scheduling fundamentals, the role of Pods, essential YAML configurations, health probes, high‑availability objects, service types, and core internal components, providing a comprehensive guide for developers and operators.
This case study outlines iQIYI's LEDAO middle‑platform monitoring challenges, evaluates open‑source solutions, details the selection and customization of CAT, and presents deployment, integration, health‑check, and alerting enhancements that now support over 100 microservices across multiple regions.
The article describes how a rapidly growing development team built a one‑click, cloud‑native platform that automates the provisioning, configuration, Docker image creation, and Kubernetes deployment of diverse test environments, addressing challenges such as heterogeneous tech stacks, middleware variety, and configuration inconsistencies.
This article provides a comprehensive step‑by‑step tutorial on designing, implementing, and deploying a simple Java Spring Boot microservice system on Kubernetes, covering architecture design, registration center, monitoring with Prometheus and Grafana, logging, tracing, flow control, and verification using tools such as Zipkin and Sentinel.
The article outlines CI/CD best practices for ToB platforms, detailing standardized branch and pipeline conventions, automated testing with Jest, versioning strategies, frontend‑backend contract design, and tools like YAPI to ensure reliable, fast, and decoupled deployments across numerous coupled systems.
WSGI (Web Server Gateway Interface) defines how Python web frameworks like Django and Flask interact with web servers, acting as a mediator that enables flexible, scalable deployment across servers such as Apache, NGINX, and containers like Gunicorn, uWSGI, and mod_wsgi.
Instead of Docker, we leveraged Go 1.16’s //embed feature to create a single binary for our web service, detailing the rapid build, test, and deployment steps, and arguing that Docker’s overhead isn’t necessary for small teams focused on fast delivery.
This article explains how to deploy a PyFlink feature platform on Kubernetes, covering basic K8s concepts, Flink execution graphs, various deployment modes, preparation steps, detailed Standalone and Native deployment procedures, and practical tips for efficient big‑data processing.
This article explains why modern enterprises need cloud‑native architecture, introduces the SESORA maturity model, and provides a detailed, practical walkthrough of deploying a cloud‑native application on Alibaba Cloud SAE, covering namespace creation, app configuration, SLB binding, service discovery, elasticity, observability, resilience, and automation.
This article explains why and how to copy production traffic to pre‑release or test environments using Nginx's ngx_http_mirror_module, covering repository setup, installation, basic start/stop commands, configuration examples, and custom compilation for full module support.
This guide walks you through troubleshooting Kubernetes Deployments by explaining the relationships between Deployments, Services, and Ingress, showing a complete YAML example, detailing label and port matching rules, and providing concrete kubectl commands and debugging techniques for Pods, Services, and Ingress.
This tutorial walks you through creating a Deployment YAML, customizing it, launching the pod, exposing it via a Service, performing rolling updates, rolling back, scaling replicas, and finally cleaning up, all with concrete kubectl commands and screenshots.
