This article explains how to package a Spring Boot application using Maven profiles and the maven‑assembly‑plugin, generate a zip release, and deploy it on Linux with a reusable shell script that handles unzip, start, stop, and restart operations.
This article introduces the open‑source visual tool NginxConfig, walks through installing Node.js and NginxConfig, shows how to configure documentation, front‑end, and API sites, generate the Nginx configuration, and deploy it on a Linux server.
This article demonstrates how to package a Spring Boot application using Maven profiles and the assembly plugin to create a zip distribution, and provides a reusable shell script (shenniu_publish.sh) for extracting, starting, stopping, and restarting the service on Linux environments.
This article provides a step‑by‑step guide on configuring a Eureka service registry on a Linux server, creating deployment scripts, setting up Jenkins to pull the Eureka JAR from Git, and editing the Spring Cloud configuration file for proper operation.
This guide demonstrates how to configure Maven profiles for different environments, use the Maven assembly and jar plugins to create a zip package of a Spring Boot application, and deploy and manage the service on Linux using a custom shell script called shenniu_publish.sh.
This article explains how to use Maven profiles and the maven‑assembly‑plugin to create environment‑specific Spring Boot zip packages, configure the accompanying assembly.xml, and deploy them on Linux with a custom shenniu_publish.sh script that supports unzip, start, stop and restart operations.
This article introduces the open‑source Wiki.js platform, explains its features, and provides a step‑by‑step guide to install it on Linux using Docker Compose, including Docker‑compose installation, configuration files, container management, and optional HTTPS setup with Caddy.
This article explains how to achieve graceful service shutdown and various deployment techniques such as blue‑green, rolling, and canary releases using Spring Cloud, Eureka, and related actuator endpoints, providing code examples and practical guidance for maintaining uninterrupted user experience during upgrades.
This article explains how to perform graceful service shutdowns and various deployment techniques—including /shutdown, /pause, and /service‑registry endpoints, EurekaAutoServiceRegistration, blue‑green, rolling, and canary deployments—using Spring Cloud to ensure zero‑downtime upgrades and smooth traffic migration.
This tutorial shows how to use the AnimeGAN v2 model to convert personal photos into comic‑style avatars, expose the AI service via a Python Bottle API on a Serverless platform, configure deployment with Serverless Devs, and integrate the backend into a WeChat mini‑program for end‑users.
This article describes how a company replaced manual host‑file based test environment access with DNS wildcard domain resolution, detailing the evolution from fixed to dynamic environments, the configuration steps on the Zhuanzhuan DNS platform, and the resulting improvements in operational efficiency and deployment simplicity.
This article introduces Cloudreve, an open‑source public cloud file system supporting multiple storage backends, outlines its key features such as direct client uploads, Aria2 integration, WebDAV, and provides step‑by‑step deployment and build instructions for Linux and Windows environments.
This guide walks you through creating a simple Express‑based HTTP server, packaging it with a bootstrap script, configuring the @serverless-devs/s tool and an s.yaml file, and finally deploying the static site to Alibaba Cloud Function Compute with a custom domain.
The article argues that launching a brand‑new project using microservices often incurs excessive infrastructure, cultural, and operational costs that outweigh the touted benefits, and suggests that a well‑designed modular monolith can be a more pragmatic alternative for many teams.
The article outlines four practical steps—application health checks, event annotation, minimizing pod impact, and blue‑green deployment—to streamline production releases, increase visibility, and reduce downtime while ensuring services run as expected.
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.
