AI 助理
备案控制台
开发者社区 云原生 文章 正文

掌握SpringBoot-2.3的容器探针：实战篇

2023-08-20 201
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 经过多篇知识积累终于来到实战章节，一起动手体验SpringBoot官方带给我们的最新技术

欢迎访问我的GitHub

  • 地址：https://github.com/zq2599/blog_demos
  • 内容：原创文章分类汇总，及配套源码，涉及Java、Docker、K8S、DevOPS等
  • 经过多篇知识积累终于来到实战章节，亲爱的读者们，请将装备就位，一起动手体验SpringBoot官方带给我们的最新技术；

    关于《SpringBoot-2.3容器化技术》系列

  • 《SpringBoot-2.3容器化技术》系列，旨在和大家一起学习实践2.3版本带来的最新容器化技术，让咱们的Java应用更加适应容器化环境，在云计算时代依旧紧跟主流，保持竞争力；
  • 全系列文章分为主题和辅助两部分，主题部分如下：
  1. 《体验SpringBoot(2.3)应用制作Docker镜像(官方方案)》；
  2. 《详解SpringBoot(2.3)应用制作Docker镜像(官方方案)》；
  3. 《掌握SpringBoot-2.3的容器探针：基础篇》；
  4. 《掌握SpringBoot-2.3的容器探针：深入篇》；
  5. 《掌握SpringBoot-2.3的容器探针：实战篇》；
  • 辅助部分是一些参考资料和备忘总结，如下：
  1. 《SpringBoot-2.3镜像方案为什么要做多个layer》；
  2. 《设置非root账号不用sudo直接执行docker命令》；
  3. 《开发阶段，将SpringBoot应用快速部署到K8S》；

    SpringBoot-2.3容器探针知识点小结

    经过前面的知识积累，我们知道了SpringBoot-2.3新增的探针规范以及适用场景，这里做个简短的回顾：
  4. kubernetes要求业务容器提供一个名为livenessProbe的地址，kubernetes会定时访问该地址，如果该地址的返回码不在200到400之间，kubernetes认为该容器不健康，会杀死该容器重建新的容器，这个地址就是存活探针；
  5. kubernetes要求业务容器提供一个名为readinessProbe的地址，kubernetes会定时访问该地址，如果该地址的返回码不在200到400之间，kubernetes认为该容器无法对外提供服务，不会把请求调度到该容器，这个地址就是就绪探针；
  6. SpringBoot的2.3.0.RELEASE发布了两个新的actuator地址，/actuator/health/liveness和/actuator/health/readiness，前者用作存活探针，后者用作就绪探针，这两个地址的返回值来自两个新增的actuator：Liveness State和Readiness State；
  7. SpringBoot应用根据特殊环境变量是否存在来判定自己是否运行在容器环境，如果是，/actuator/health/liveness和/actuator/health/readiness这两个地址就有返回码，具体的值是和应用的状态有对应关系的，例如应用启动过程中，/actuator/health/readiness返回503，启动成功后返回200；
  8. 业务应用可以通过Spring系统事件机制来读取Liveness State和Readiness State，也可以订阅这两个actuator的变更事件；
  9. 业务应用可以通过Spring系统事件机制来修改Liveness State和Readiness State，此时/actuator/health/liveness和/actuator/health/readiness的返回值都会发生变更，从而影响kubernetes对此容器的行为（参照第一点和第二点），例如livenessProbe返回码变成503，导致kubernetes认为容器不健康，从而杀死容器；

小结完毕，接下来开始实打实的编码和操作实战，验证上述理论；

实战环境信息

本次实战有两个环境：开发和运行环境，其中开发环境信息如下：

  1. 操作系统：Ubuntu 20.04 LTS 桌面版
  2. CPU ：2.30GHz × 4，内存：32G，硬盘：1T NVMe
  3. JDK：1.8.0_231
  4. MAVEN：3.6.3
  5. SpringBoot：2.3.0.RELEASE
  6. Docker：19.03.10
  7. 开发工具：IDEA 2020.1.1 (Ultimate Edition)

运行环境信息如下：

  1. 操作系统：CentOS Linux release 7.8.2003
  2. Kubernetes：1.15

事实证明，用Ubuntu桌面版作为开发环境是可行的，体验十分顺畅，IDEA、SubLime、SSH、Chrome、微信都能正常使用，下图是我的Ubuntu开发环境：
在这里插入图片描述

实战内容简介

本次实战包括以下内容：

  1. 开发SpringBoot应用，部署在kubernetes；
  2. 检查应用状态和kubernetes的pod状态的关联变化；
  3. 修改Readiness State，看kubernetes是否还会把请求调度到pod；
  4. 修改Liveness State，看kubernetes会不是杀死pod；

    源码下载

  5. 本次实战用到了一个普通的SpringBoot工程，源码可在GitHub下载到，地址和链接信息如下表所示(https://github.com/zq2599/blog_demos)：
名称 链接 备注
项目主页 https://github.com/zq2599/blog_demos 该项目在GitHub上的主页
git仓库地址(https) https://github.com/zq2599/blog_demos.git 该项目源码的仓库地址，https协议
git仓库地址(ssh) git@github.com:zq2599/blog_demos.git 该项目源码的仓库地址，ssh协议
  1. 这个git项目中有多个文件夹，本章的应用在probedemo文件夹下，如下图红框所示：
    在这里插入图片描述

    开发SpringBoot应用

  2. 请在IDEA上安装lombok插件：
    在这里插入图片描述
  3. 在IDEA上新建名为probedemo的SpringBoot工程，版本选择2.3.0：
    在这里插入图片描述

  4. 该工程的pom.xml内容如下，注意要有spring-boot-starter-actuator和lombok依赖，另外插件spring-boot-maven-plugin也要增加layers节点：

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <parent>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-parent</artifactId>
     <version>2.3.0.RELEASE</version>
     <relativePath/> <!-- lookup parent from repository -->
 </parent>
 <groupId>com.bolingcavalry</groupId>
 <artifactId>probedemo</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <name>probedemo</name>
 <description>Demo project for Spring Boot</description>

 <properties>
     <java.version>1.8</java.version>
 </properties>

 <dependencies>
     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
     </dependency>

     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
         <exclusions>
             <exclusion>
                 <groupId>org.junit.vintage</groupId>
                 <artifactId>junit-vintage-engine</artifactId>
             </exclusion>
         </exclusions>
     </dependency>
     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-actuator</artifactId>
     </dependency>

     <dependency>
         <groupId>org.projectlombok</groupId>
         <artifactId>lombok</artifactId>
     </dependency>
 </dependencies>

 <build>
     <plugins>
         <plugin>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-maven-plugin</artifactId>
             <version>2.3.0.RELEASE</version>
             <!--该配置会在jar中增加layer描述文件，以及提取layer的工具-->
             <configuration>
                 <layers>
                     <enabled>true</enabled>
                 </layers>
             </configuration>
         </plugin>
     </plugins>
 </build>
</project>

  5. 应用启动类ProbedemoApplication是个最普通的启动类：

package com.bolingcavalry.probedemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ProbedemoApplication {
   
    public static void main(String[] args) {
   
        SpringApplication.run(ProbedemoApplication.class, args);
    }
}
  1. 增加一个监听类，可以监听存活和就绪状态的变化：
package com.bolingcavalry.probedemo.listener;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.availability.AvailabilityChangeEvent;
import org.springframework.boot.availability.AvailabilityState;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

/**
 * description: 监听系统事件的类 <br>
 * date: 2020/6/4 下午12:57 <br>
 * author: willzhao <br>
 * email: zq2599@gmail.com <br>
 * version: 1.0 <br>
 */
@Component
@Slf4j
public class AvailabilityListener {
   

    /**
     * 监听系统消息，
     * AvailabilityChangeEvent类型的消息都从会触发此方法被回调
     * @param event
     */
    @EventListener
    public void onStateChange(AvailabilityChangeEvent<? extends AvailabilityState> event) {
   
        log.info(event.getState().getClass().getSimpleName() + " : " + event.getState());
    }
}
  1. 增加名为StateReader的Controller的Controller，用于获取存活和就绪状态：
package com.bolingcavalry.probedemo.controller;

import org.springframework.boot.availability.ApplicationAvailability;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import java.util.Date;

@RestController
@RequestMapping("/statereader")
public class StateReader {
   

    @Resource
    ApplicationAvailability applicationAvailability;

    @RequestMapping(value="/get")
    public String state() {
   
        return "livenessState : " + applicationAvailability.getLivenessState()
               + "<br>readinessState : " + applicationAvailability.getReadinessState()
               + "<br>" + new Date();
    }
}
  1. 增加名为StateWritter的Controller，用于设置存活和就绪状态：
package com.bolingcavalry.probedemo.controller;

import org.springframework.boot.availability.AvailabilityChangeEvent;
import org.springframework.boot.availability.LivenessState;
import org.springframework.boot.availability.ReadinessState;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.Date;

/**
 * description: 修改状态的controller <br>
 * date: 2020/6/4 下午1:21 <br>
 * author: willzhao <br>
 * email: zq2599@gmail.com <br>
 * version: 1.0 <br>
 */
@RestController
@RequestMapping("/staterwriter")
public class StateWritter {
   

    @Resource
    ApplicationEventPublisher applicationEventPublisher;

    /**
     * 将存活状态改为BROKEN（会导致kubernetes杀死pod）
     * @return
     */
    @RequestMapping(value="/broken")
    public String broken(){
   
        AvailabilityChangeEvent.publish(applicationEventPublisher, StateWritter.this, LivenessState.BROKEN);
        return "success broken, " + new Date();
    }

    /**
     * 将存活状态改为CORRECT
     * @return
     */
    @RequestMapping(value="/correct")
    public String correct(){
   
        AvailabilityChangeEvent.publish(applicationEventPublisher, StateWritter.this, LivenessState.CORRECT);
        return "success correct, " + new Date();
    }

    /**
     * 将就绪状态改为REFUSING_TRAFFIC（导致kubernetes不再把外部请求转发到此pod）
     * @return
     */
    @RequestMapping(value="/refuse")
    public String refuse(){
   
        AvailabilityChangeEvent.publish(applicationEventPublisher, StateWritter.this, ReadinessState.REFUSING_TRAFFIC);
        return "success refuse, " + new Date();
    }

    /**
     * 将就绪状态改为ACCEPTING_TRAFFIC（导致kubernetes会把外部请求转发到此pod）
     * @return
     */
    @RequestMapping(value="/accept")
    public String accept(){
   
        AvailabilityChangeEvent.publish(applicationEventPublisher, StateWritter.this, ReadinessState.ACCEPTING_TRAFFIC);
        return "success accept, " + new Date();
    }

}
  1. 增加名为Hello的controller，此接口能返回当前pod的IP地址，在后面测试时会用到：
package com.bolingcavalry.probedemo.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import java.util.List;

/**
 * description: hello demo <br>
 * date: 2020/6/4 下午4:38 <br>
 * author: willzhao <br>
 * email: zq2599@gmail.com <br>
 * version: 1.0 <br>
 */
@RestController
public class Hello {
   

    /**
     * 返回的是当前服务器IP地址，在k8s环境就是pod地址
     * @return
     * @throws SocketException
     */
    @RequestMapping(value="/hello")
    public String hello() throws SocketException {
   
        List<Inet4Address> addresses = getLocalIp4AddressFromNetworkInterface();
        if(null==addresses || addresses.isEmpty()) {
   
            return  "empty ip address, " + new Date();
        }

        return addresses.get(0).toString() + ", " + new Date();
    }

    public static List<Inet4Address> getLocalIp4AddressFromNetworkInterface() throws SocketException {
   
        List<Inet4Address> addresses = new ArrayList<>(1);
        Enumeration e = NetworkInterface.getNetworkInterfaces();
        if (e == null) {
   
            return addresses;
        }
        while (e.hasMoreElements()) {
   
            NetworkInterface n = (NetworkInterface) e.nextElement();
            if (!isValidInterface(n)) {
   
                continue;
            }
            Enumeration ee = n.getInetAddresses();
            while (ee.hasMoreElements()) {
   
                InetAddress i = (InetAddress) ee.nextElement();
                if (isValidAddress(i)) {
   
                    addresses.add((Inet4Address) i);
                }
            }
        }
        return addresses;
    }

    /**
     * 过滤回环网卡、点对点网卡、非活动网卡、虚拟网卡并要求网卡名字是eth或ens开头
     * @param ni 网卡
     * @return 如果满足要求则true，否则false
     */
    private static boolean isValidInterface(NetworkInterface ni) throws SocketException {
   
        return !ni.isLoopback() && !ni.isPointToPoint() && ni.isUp() && !ni.isVirtual()
                && (ni.getName().startsWith("eth") || ni.getName().startsWith("ens"));
    }

    /**
     * 判断是否是IPv4，并且内网地址并过滤回环地址.
     */
    private static boolean isValidAddress(InetAddress address) {
   
        return address instanceof Inet4Address && address.isSiteLocalAddress() && !address.isLoopbackAddress();
    }
}

以上就是该SpringBoot工程的所有代码了，请确保可以编译运行；

制作Docker镜像

  1. 在pom.xml所在目录创建文件Dockerfile，内容如下：
# 指定基础镜像，这是分阶段构建的前期阶段
FROM openjdk:8u212-jdk-stretch as builder
# 执行工作目录
WORKDIR application
# 配置参数
ARG JAR_FILE=target/*.jar
# 将编译构建得到的jar文件复制到镜像空间中
COPY ${JAR_FILE} application.jar
# 通过工具spring-boot-jarmode-layertools从application.jar中提取拆分后的构建结果
RUN java -Djarmode=layertools -jar application.jar extract

# 正式构建镜像
FROM openjdk:8u212-jdk-stretch
WORKDIR application
# 前一阶段从jar中提取除了多个文件，这里分别执行COPY命令复制到镜像空间中，每次COPY都是一个layer
COPY --from=builder application/dependencies/ ./
COPY --from=builder application/spring-boot-loader/ ./
COPY --from=builder application/snapshot-dependencies/ ./
COPY --from=builder application/application/ ./
ENTRYPOINT ["java", "org.springframework.boot.loader.JarLauncher"]
  1. 先编译构建工程，执行以下命令：
    mvn clean package -U -DskipTests

  2. 编译成功后，通过Dockerfile文件创建镜像：

    sudo docker build -t bolingcavalry/probedemo:0.0.1 .

  3. 镜像创建成功：
    在这里插入图片描述
    SpringBoot的镜像准备完毕，接下来要让kubernetes环境用上这个镜像；

    将镜像加载到kubernetes环境

    此时的镜像保存在开发环境的电脑上，可以有以下三种方式加载到kubernetes环境：

  4. push到私有仓库，kubernetes上使用时也从私有仓库获取；
  5. push到hub.docker.com，kubernetes上使用时也从hub.docker.com获取，目前我已经将此镜像push到hub.docker.com，您在kubernetes直接使用即可，就像nginx、tomcat这些官方镜像一样下载；
  6. 在开发环境执行docker save bolingcavalry/probedemo:0.0.1 > probedemo.tar，可将此镜像另存为本地文件，再scp到kubernetes服务器，再在kubernetes服务器执行docker load < /root/temp/202006/04/probedemo.tar就能加载到kubernetes服务器的本地docker缓存中；

以上三种方法的优缺点整理如下：

  1. 首推第一种，但是需要您搭建私有仓库；
  2. 由于springboot-2.3官方对镜像构建作了优化，第二种方法也就执行第一次的时候上传和下载很耗时，之后修改java代码重新构建时，不论上传还是下载都很快（只上传下载某个layer）；
  3. 在开发阶段，使用第三种方法最为便捷，但如果kubernetes环境有多台机器，就不合适了，因为镜像是存在指定机器的本地缓存的；

我的kubernetes环境只有一台电脑，因此用的是方法三，参考命令如下(建议安装sshpass，就不用每次输入帐号密码了)：

# 将镜像保存为tar文件
sudo docker save bolingcavalry/probedemo:0.0.1 > probedemo.tar

# scp到kubernetes服务器
sshpass -p 888888 scp ./probedemo.tar root@192.168.50.135:/root/temp/202006/04/ 

# 远程执行ssh命令，加载docker镜像
sshpass -p 888888 ssh root@192.168.50.135 "docker load < /root/temp/202006/04/probedemo.tar"

kubernetes部署deployment和service

  1. 在kubernetes创建名为probedemo.yaml的文件，内容如下，注意pod副本数是2，另外请关注livenessProbe和readinessProbe的参数配置：
apiVersion: v1
kind: Service
metadata:
  name: probedemo
spec:
  type: NodePort
  ports:
    - port: 8080
      nodePort: 30080
  selector:
    name: probedemo
---
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: probedemo
spec:
  replicas: 2
  template:
    metadata:
      labels:
        name: probedemo
    spec:
      containers:
        - name: probedemo
          image: bolingcavalry/probedemo:0.0.1
          tty: true
          livenessProbe:
            httpGet:
              path: /actuator/health/liveness
              port: 8080
            initialDelaySeconds: 5
            failureThreshold: 10
            timeoutSeconds: 10
            periodSeconds: 5
          readinessProbe:
            httpGet:
              path: /actuator/health/readiness
              port: 8080
            initialDelaySeconds: 5
            timeoutSeconds: 10
            periodSeconds: 5
          ports:
            - containerPort: 8080
          resources:
            requests:
              memory: "512Mi"
              cpu: "100m"
            limits:
              memory: "1Gi"
              cpu: "500m"
  1. 执行命令kubectl apply -f probedemo..yaml，即可创建deployment和service：
    在这里插入图片描述
  2. 这里要重点关注的是livenessProbe的initialDelaySeconds和failureThreshold参数，initialDelaySeconds等于5，表示pod创建5秒后检查存活探针，如果10秒内应用没有完成启动，存活探针不返回200，就会重试10次(failureThreshold等于10)，如果重试10次后存活探针依旧无法返回200，该pod就会被kubernetes杀死重建，要是每次启动都耗时这么长，pod就会不停的被杀死重建；
  3. 执行命令kubectl apply -f probedemo.yaml，创建deployment和service，如下图，可见在第十秒的时候pod创建成功，但是此时还未就绪：
    在这里插入图片描述
  4. 继续查看状态，创建一分钟后两个pod终于就绪：
    在这里插入图片描述
  5. 用kubectl describe命令查看pod状态，事件通知显示存活和就绪探针都有失败情况，不过因为有重试，因此后来状态会变为成功：
    在这里插入图片描述
    至此，从编码到部署都完成了，接下来验证SpringBoot-2.3.0.RELEASE的探针技术；

    验证SpringBoot-2.3.0.RELEASE的探针技术

  6. 监听类AvailabilityListener的作用是监听状态变化，看看pod日志，看AvailabilityListener的代码是否有效，如下图红框，在应用启动阶段AvailabilityListener被成功回调，打印了存活和就绪状态：
    在这里插入图片描述
  7. kubernetes所在机器的IP地址是192.168.50.135，因此SpringBoot服务的访问地址是http://192.168.50.135:30080/xxx
  8. 访问地址http://192.168.50.135:30080/actuator/health/liveness，返回码如下图红框，可见存活探针已开启：
    在这里插入图片描述
  9. 就绪探针也正常：
    在这里插入图片描述
  10. 打开两个浏览器，都访问：http://192.168.50.135:30080/hello，多次Ctrl+F5强刷，如下图，很快就能得到不同结果，证明响应来自不同的Pod：
    在这里插入图片描述
  11. 访问：http://192.168.50.135:30080/statereader/get，可以得到存活和就绪的状态，可见StateReader的代码已经生效，可以通过ApplicationAvailability接口取得状态：
    在这里插入图片描述
  12. 修改就绪状态，访问：http://192.168.50.135:30080/statewriter/refuse，如下图红框，可见收到请求的pod，其就绪状态已经出现了异常，证明StateWritter.java中修改就绪状态后，可以让kubernetes感知到这个pod的异常：
    在这里插入图片描述
  13. 用浏览器反复强刷hello接口，返回的Pod地址也只有一个，证明只有一个Pod在响应请求：
    在这里插入图片描述

  14. 尝试恢复服务，注意请求要在服务器后台发送，而且IP地址要用刚才被设置为refuse的pod地址：

    curl http://10.233.90.195:8080/statewriter/accept

  15. 如下图，状态已经恢复：
    在这里插入图片描述

  16. 最后再来试试将存活状态从CORRECT改成BROKEN，浏览器访问：http://192.168.50.135:30080/statewriter/broken
  17. 如下图红框，重启次数变成1，表示pod被杀死了一次，并且由于重启导致当前还未就绪，证明在SpringBoot中修改了存活探针的状态，是会触发kubernetes杀死pod的：
    在这里插入图片描述
  18. 等待pod重启、就绪探针正常后，一切恢复如初：
    在这里插入图片描述
  19. 强刷浏览器，如下图红框，两个Pod都能正常响应：
    在这里插入图片描述

    官方忠告

  • 至此，《掌握SpringBoot-2.3的容器探针》系列就全部完成了，从理论到实践，咱们一起学习了SpringBoot官方带给我们的容器化技术，最后以一段官方忠告来结尾，大家一起将此忠告牢记在心：
    在这里插入图片描述
  • 我对以上内容的理解：选择外部系统的服务作为探针的时候要谨慎（外部系统可能是数据库，也可能是其他web服务），如果外部系统出现问题，会导致kubernetes杀死pod(存活探针问题)，或者导致kubernetes不再调度请求到pod(就绪探针问题)；（再请感谢大家容忍我的英语水平）

欢迎关注阿里云开发者社区：程序员欣宸

学习路上，你不孤单，欣宸原创一路相伴...

文章标签：
容器服务Kubernetes版
Java
容器
Kubernetes
Perl
Docker
关键词：
容器实战
容器探针
Spring Boot容器
springboot容器
springboot-2.3容器探针
相关实践学习
通过Ingress进行灰度发布
本场景您将运行一个简单的应用，部署一个新的应用用于新的发布，并通过Ingress能力实现灰度发布。
容器应用与集群管理
欢迎来到《容器应用与集群管理》课程，本课程是“云原生容器Clouder认证“系列中的第二阶段。课程将向您介绍与容器集群相关的概念和技术，这些概念和技术可以帮助您了解阿里云容器服务ACK/ACK Serverless的使用。同时，本课程也会向您介绍可以采取的工具、方法和可操作步骤，以帮助您了解如何基于容器服务ACK Serverless构建和管理企业级应用。 学习完本课程后，您将能够： 掌握容器集群、容器编排的基本概念 掌握Kubernetes的基础概念及核心思想 掌握阿里云容器服务ACK/ACK Serverless概念及使用方法 基于容器服务ACK Serverless搭建和管理企业级网站应用
程序员欣宸
目录
相关文章
是乙太呀
|
3天前
|
关系型数据库 应用服务中间件 PHP
实战~如何组织一个多容器项目docker-compose
本文介绍了如何使用Docker搭建Nginx、PHP和MySQL的环境。首先启动Nginx容器并查看IP地址，接着启动Alpine容器并安装curl测试连通性。通过`--link`方式或`docker-compose`配置文件实现服务间的通信。最后展示了Nginx配置文件和PHP代码示例，验证了各服务的正常运行。
是乙太呀
18 3
实战~如何组织一个多容器项目docker-compose
蓝染-惣右介
|
1月前
|
Java 应用服务中间件 Linux
【Docker容器化技术】docker安装与部署、常用命令、容器数据卷、应用部署实战、Dockerfile、服务编排docker-compose、私有仓库
本文主要讲解了Docker的安装与部署、常用命令、容器数据卷、应用部署实战、Dockerfile、服务编排docker-compose、私有仓库以及Docker容器虚拟化与传统虚拟机比较。
蓝染-惣右介
534 11
【Docker容器化技术】docker安装与部署、常用命令、容器数据卷、应用部署实战、Dockerfile、服务编排docker-compose、私有仓库
龙大吉
|
19天前
|
存储 缓存 监控
Docker容器性能调优的关键技巧，涵盖CPU、内存、网络及磁盘I/O的优化策略，结合实战案例，旨在帮助读者有效提升Docker容器的性能与稳定性。
本文介绍了Docker容器性能调优的关键技巧，涵盖CPU、内存、网络及磁盘I/O的优化策略，结合实战案例，旨在帮助读者有效提升Docker容器的性能与稳定性。
龙大吉
54 7
小周sir
|
24天前
|
Kubernetes Linux 开发者
深入探索容器化技术——Docker 的实战应用
深入探索容器化技术——Docker 的实战应用
小周sir
54 5
游客moiomvrp3vyac2
|
28天前
|
运维 Cloud Native 云计算
云原生之旅：Docker容器化实战
本文将带你走进云原生的世界，深入理解Docker技术如何改变应用部署与运维。我们将通过实际案例，展示如何利用Docker简化开发流程，提升应用的可移植性和伸缩性。文章不仅介绍基础概念，还提供操作指南和最佳实践，帮助你快速上手Docker，开启云原生的第一步。
游客moiomvrp3vyac2
55 8
游客762btuqu5wybw666
|
27天前
|
存储 安全 Java
Java多线程编程中的并发容器：深入解析与实战应用####
在本文中，我们将探讨Java多线程编程中的一个核心话题——并发容器。不同于传统单一线程环境下的数据结构，并发容器专为多线程场景设计，确保数据访问的线程安全性和高效性。我们将从基础概念出发，逐步深入到`java.util.concurrent`包下的核心并发容器实现，如`ConcurrentHashMap`、`CopyOnWriteArrayList`以及`BlockingQueue`等，通过实例代码演示其使用方法，并分析它们背后的设计原理与适用场景。无论你是Java并发编程的初学者还是希望深化理解的开发者，本文都将为你提供有价值的见解与实践指导。 --- ####
游客762btuqu5wybw666
42 3
有路有乔-六月
|
1月前
|
机器学习/深度学习 数据采集 Docker
Docker容器化实战：构建并部署一个简单的Web应用
Docker容器化实战：构建并部署一个简单的Web应用
有路有乔-六月
37 4
Star时光
|
21天前
|
Kubernetes Linux 开发者
深入探索容器化技术——Docker 的实战应用
深入探索容器化技术——Docker 的实战应用
Star时光
67 0
Star时光
|
22天前
|
存储 Cloud Native 开发者
深入探索容器化技术——Docker的实战应用
深入探索容器化技术——Docker的实战应用
Star时光
35 0
Star时光
|
23天前
|
JavaScript Linux 持续交付
深入探索容器化技术——Docker 的实战应用
深入探索容器化技术——Docker 的实战应用
Star时光
47 0

热门文章

最新文章

  • 1
    docker容器里安装ssh
  • 2
    Docker容器使用问题：Failed to get D-Bus connection: Operation not permitted
  • 3
    美国国家标准技术局发布应用容器安全指南  
  • 4
    ElasticSearch容器化从0到1实践（一）
  • 5
    Ioc容器概述
  • 6
    如何利用Docker进行PHP应用程序的容器化部署？
  • 7
    WinForm容器内控件批量效验是否允许为空？设置是否只读？设置是否可用等方法分享
  • 8
    Spring Aware容器感知技术
  • 9
    Kubernetes容器运行时接口-CRI
  • 10
    STL各种容器的使用时机详解
  • 1
    springboot实现文件防盗链设计
    126
  • 2
    Spring Boot中一般如何使用线程池？
    752
  • 3
    Spring Boot 源码面试知识点
    100
  • 4
    【MongoDB 专栏】MongoDB 与 Spring Boot 的集成实践
    253
  • 5
    深入探索Spring Boot Web应用源码及实战应用
    105
  • 6
    ruoyi-nbcio从spring2.7.18升级springboot到3.1.7，java从java8升级到17（二）
    350
  • 7
    springboot数据库回滚失败原因
    62
  • 8
    springboot全局自定义异常
    44
  • 9
    springBoot+rabbit消息获取和消息确认
    126
  • 10
    RabbitMQ的springboot项目集成使用-01
    147

    • 相关课程

    更多
  • 基于容器搭建企业级应用
  • 容器持久化储存训练营
  • 现代应用容器技术快速入门
  • 云计算、容器和云原生基础课程
  • Serverless 容器从入门到精通: - Serverless Kubernetes
  • 容器安全与Palo Alto Networks解决方案

    • 相关电子书

    更多
  • 使用CNFS搭建弹性Web服务
  • 阿里云文件存储 NAS 在容器场景的最佳实践
  • 何种数据存储才能助力容器计算

    • 相关实验场景

    更多
  • 通过容器镜像仓库与容器服务快速部署spring-hello应用
  • 容器中的volume卷
  • 容器的文件系统挂载
  • 容器的配置和存储
  • 容器DevSecOps全链路体验
  • 容器的启动和操作
    • 下一篇
    阿里云oss存储简介和如何使用