购买青云服务器及docker命令、制作java应用镜像初体验。

docker学了很多时间了，但是业务中使用的时候一直很少，很多都快忘了，所以这里自己搞一个服务器装个docker玩玩。

购买青云服务器

青云新用户注册后会送你五百多的费用，我们可以使用按需付费的方式购买云服务器做实验（相当于免费）。

产品与服务->云服务器->创建：

最后，点击立即购买就行，由于我们是新用户，有五百多的赠送费用，所以这里就不用花钱了。

购买之后在工作台云服务器那可以看到我们的机器：

直接使用xshell，或securtCRT等远程连接工具，使用这个公网Ip和我们root，及我们设置的密码连接就行。

如果你临时有事出去了，想知道如果关闭或减少计费，可以先看最后一小节。

安装docker

  1. #删除所有docker相关的东西
  2. yum remove docker*
  4. #安装docker所需的东西
  5. yum install -y yum-utils
  7. #配置docker的yum源
  8. yum-config-manager \
  9. --add-repo \
  10. http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
  12. #安装docker及相关（大概耗时几分钟）
  13. yum install -y docker-ce docker-ce-cli containerd.io
  15. #设置docker开机启动，并立即启动docker
  16. systemctl enable docker --now
  18. #看docker命令是否正常输出docker信息
  19. docker info
  21. #配置docker下载镜像加速地址，下面这些直接全部赋值粘贴执行即可
  22. sudo mkdir -p /etc/docker
  23. sudo tee /etc/docker/daemon.json <<-'EOF'
  24. {
  25.   "registry-mirrors": ["https://d7f29occ.mirror.aliyuncs.com"],
  26.   "exec-opts": ["native.cgroupdriver=systemd"],
  27.   "log-driver": "json-file",
  28.   "log-opts": {
  29.     "max-size": "100m"
  30.   },
  31.   "storage-driver": "overlay2"
  32. }
  33. EOF
  34. sudo systemctl daemon-reload
  35. sudo systemctl restart docker

安装nginx实验

  1. #拉取nginx镜像
  2. docker pull nginx
  4. #查看本地镜像，会看到nginx以及下载下来了
  5. docker images
  7. #运行nginx容器
  8. #-d后台运行
  9. #-p端口映射（主机端口:docker容器端口）
  10. #--name容器名字
  11. #--restart主机重启时容器执行策略
  12. docker run -d -p 80:80 --name mynginx --restart=always nginx
  14. #查看正在运行的容器，可以看到nginx正在运行
  15. docker ps

在青云后台中，添加80端口的安全组策略（别忘了点击“应用修改”按钮），然后就能在浏览器通过服务器的公网ip访问，可以看到nginx的首页。

部署Java应用

我们可以通过docker部署Java应用

写一个最简单的SpringBoot应用，连接redis。

安装redis

  1. #拉取redis镜像
  2. docker pull redis

在docker hub中查找redis，可以看到docker容器里的redis数据是存放在/data目录的，所以我们需要将其挂载出来。

另外，也可以看到docker容器里的redis配置文件是在这个位置，所以我们也要把他挂载出来。

在宿主机创建对应的数据目录和配置文件：

  1. mkdir -p /data/redis/data
  2. echo "appendonly yes" > /data/redis/redis.conf

启动redis容器

  1. #docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
  2. #最后的redis-server /etc/redis/redis.conf是[COMMAND]部分，让redis启动时去加载配置文件。在上图中也能够看到官方也有说明
  3. docker run -d -p 6379:6379 --name myredis --restart=always \
  4. -v /data/redis/redis.conf:/usr/local/etc/redis/redis.conf \
  5. -v /data/redis/data:/data \
  6. redis \
  7. redis-server /usr/local/etc/redis/redis.conf
  9. #查看容器是否正常启动，最后多看几次，有时候刚开始是正常，过了两三秒就不正常了
  10. docker ps

刚刚忘记给redis设置密码了，修改下配置文件：

  1. vi /data/redis/redis.conf
  2. #添加内容：requirepass abc123456
  4. #重启redis
  5. docker restart myredis

在青云页面安全组中开放端口6379（别忘了点击“应用修改”按钮），然后就可以使用客户端工具连接一下看能否正常连接使用redis。

Java应用

使用SpringBoot快速初始化一个最简单的项目：

pom：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>2.6.6</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  11.     <groupId>com.example</groupId>
  12.     <artifactId>demo</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <name>demo</name>
  15.     <description>Demo project for Spring Boot</description>
  16.     <properties>
  17.         <java.version>1.8</java.version>
  18.     </properties>
  19.     <dependencies>
  20.         <dependency>
  21.             <groupId>org.springframework.boot</groupId>
  22.             <artifactId>spring-boot-starter-data-redis</artifactId>
  23.         </dependency>
  24.         <dependency>
  25.             <groupId>org.springframework.boot</groupId>
  26.             <artifactId>spring-boot-starter-web</artifactId>
  27.         </dependency>
  29.         <dependency>
  30.             <groupId>org.springframework.boot</groupId>
  31.             <artifactId>spring-boot-starter-test</artifactId>
  32.             <scope>test</scope>
  33.         </dependency>
  34.     </dependencies>
  36.     <build>
  37.         <plugins>
  38.             <plugin>
  39.                 <groupId>org.springframework.boot</groupId>
  40.                 <artifactId>spring-boot-maven-plugin</artifactId>
  41.             </plugin>
  42.         </plugins>
  43.     </build>
  45. </project>

TestController：

  1. package com.example.demo.controller;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.data.redis.core.StringRedisTemplate;
  5. import org.springframework.web.bind.annotation.GetMapping;
  6. import org.springframework.web.bind.annotation.RestController;
  8. /**
  9.  * @author: HanXu
  10.  * on 2022/4/10
  11.  * Class description:
  12.  */
  13. @RestController
  14. public class TestController {
  16.     @Autowired
  17.     private StringRedisTemplate redisTemplate;
  19.     @GetMapping("/hello")
  20.     public String hello() {
  21.         Long count = redisTemplate.opsForValue().increment("count");
  22.         return "第【" + count + "】人访问";
  23.     }
  24. }

application.properties：

  1. spring.redis.host=139.198.169.10
  2. spring.redis.password=abc123456

启动，访问http://localhost:8080/hello：我这是刷新了几次后的截图

制作Java应用镜像

制作镜像使用的是Dockerfile。

在项目目录下创建Dockerfile文件：

内容如下：

  1. # 环境，java就是openjdk，注意去docker hub上找jdk镜像，然后在tag那里找一个linux版本的 jdk8的
  2. FROM openjdk:8-jdk-slim
  3. # 作者
  4. LABEL maintainer=xxx
  6. # 将当前目录下的target下的jar包拷贝到docker容器里那个小系统的/app.jar文件
  7. COPY target/*.jar   /app.jar
  9. # 启动命令，就是当我们以docker run启动这个打包好的镜像之后，镜像启动内部会做什么事情
  10. # CMD也可以，ENTRYPOINT也可以
  11. ENTRYPOINT ["java","-jar","/app.jar"]

接下来需要构建镜像，这需要用到docker命令，我电脑上没有docker，因此就上传到服务器上去做。

我们构建时只需要用到target下的jar包和Dockerfile文件，所以我们将他俩拷贝出来上传到服务器上。（如果的target下没有jar包，那就用maven package打下包）

目录结构如下：

我们将aaa目录整体上传到服务器。（没有rz命令可以使用yum -y install lrzsz 安装），上传后如下。

构建打包：

  1. # 构建打包
  2. #-t就是-tag，标签名，全称（镜像名:版本）最后的.表示以当前目录为工作目录
  3. #因为docker构建时，要拉下来一个小linux系统，然后根据Dockerfile的命令，装上openjdk，在执行COPY target/*.jar   /app.jar，执行时就是找当前目录下的target目录，然后将里面的jar包copy到新的linux系统中的/目录下，并命名为app.jar（因为我们只有一个jar，所以可以这样做）。最终执行java -jar /app.jar命令
  4. docker build -t docker-demo:v1.0 .
  6. #查看镜像
  7. docker images

启动容器：

像启动其他容器一样启动这个Java应用镜像

  1. docker run -d -p 8080:8080 --name mydocker-demo docker-demo:v1.0

在青云页面安全组中开放端口8080（别忘了点击“应用修改”按钮），然后就可以访问页面了：http://ip:8080/hello，并且数据也是接着刚才的：

推送镜像

我们还可以将刚刚制作的java镜像推送到docker hub上，供他人使用或者自己记录。在公司中，一般都有内部搭建的harbor，每次发版都需要制作镜像并推送到harbor上。这样就有了每次发版的历史镜像，想要快速回退到某个版本是非常方便的。

我们要推送到docker hub，首先要注册登录docker hub：https://hub.docker.com/。

然后你会有一个自己的docker id，邮箱，密码：hanhanhanxu就是我的docker id。就像github的账号一样，它是不允许重复的。

在服务器命令行登录docker：

  1. #只要登录一次，后面就不需要登录了。输入docker id和密码
  2. docker login
  4. #给镜像其别名，这个新名字必须是你的docker id/新镜像名字:版本号。
  5. #在公司里，如果有harbor服务的话，一般前缀会是harbor地址，表示要向这个地址推送镜像。
  6. #我们使用公共的docker hub所以就不需要写地址，只需要告诉他你的docker id是什么，就能往对应的账户中推送镜像了。
  7. docker tag docker-demo:v1.0 hanhanhanxu/docker-demo:v1.0

打好tag后本地镜像会多出一个差不多相同的镜像（其实都是同一个，只是打了标签）。

推送镜像

  1. #这个过程可能会有一两分钟
  2. docker push hanhanhanxu/docker-demo:v1.0

现在，我们就可以在任何一台装有docker并联网的机器上使用我们推送的镜像了。

在新机器拉取我们刚刚上传的镜像：

  1. #拉取镜像
  2. docker pull hanhanhanxu/docker-demo:v1.0
  4. #启动容器
  5. docker run -d -p 8080:8080 hanhanhanxu/docker-demo:v1.0
  7. #查看是否启动成功
  8. docker ps

访问http://ip:8080/hello ，这个ip需要是你启动这个容器的机器的公网ip。

排错

如果我么在启动容器中发生了错误，那么则可以查看容器日志：

  1. #查看容器启动情况，发现容器没有正常启动
  2. docker ps
  4. #查看日志
  5. docker logs 容器id
  7. #-f参数滚动查看日志，和tail差不多
  8. docker logs -f 容器id
  10. #如果有什么简单的小错误，或者可以直接修改掉的，可以进入容器修改
  11. # 进入容器内部的系统，修改容器内容；-it 以交互模式进入；/bin/bash 进入bash控制台，就跟Linux的命令行界面一样。有的是/bin/bash 有的是/bin/sh
  12. docker exec -it 容器id  /bin/bash
  13. # 改好后直接exit推出就行
  14. exit
  16. #忘记加什么启动配置了，可以动态修改
  17. #修改容器配置，添加应用开机自启的配置项（update操作不能修改端口映射）
  18. docker update 容器id/名字 --restart=always
  20. #停止容器
  21. docker stop 容器id/名字
  22. #再次启动，必须是曾经docker run过的
  23. docker start 容器id/名字
  25. #或者强制删掉容器重来
  26. docker rm -f 容器id

删除资源

选择机器，更多操作，直接删除：

还有公网ip也会产生费用，删掉（选中，更多操作，删除）：

看一下费用：

找了一下发现有效期到7月多，差不多是100天的，那挺好啊：