Docker instala Jenkins para empaquetar el proyecto Maven como una imagen de Docker y ejecutarlo [enseñanza gráfica a nivel de niñera]

I. Introducción

Como pionero de CI y CD, Jenkins no es tan popular como Gitlab ahora, pero sigue siendo fuerte y fuerte, y muchas pequeñas y medianas empresas todavía lo usan ampliamente. Recientemente, el editor experimentó con un paquete de Jenkins y se siente bastante bien, así que lo aprendí por mi cuenta. Muchos tutoriales en Internet son para compilar Jenkins en Linux.Después de una semana de exploración, el editor finalmente completó la compilación en la ventana acoplable.

La versión final es: cargue el código a través de git —> use Jenkins para crear un empaquetado automático —> empaquete el paquete jar en una imagen acoplable, ejecútelo en la ventana acoplable y acceda a él en Windows

¡Principalmente registre algunas trampas y puntos de atención que se hayan pisado, para que luego las personas puedan seguir al editor para completarlo de una vez! !

2. Instalar ventana acoplable

Instalar ventana acoplable

3. Instalar jdk y maven en linux

1. Descarga la versión JDK8Linux

La descarga del sitio web oficial es demasiado lenta, Xiaobian aquí para descargarla para todos:

Enlace: dirección de disco de red de Baidu
Código de extracción: ov24

2. Descarga Maven

enlace de descarga maven3.8.5

3. Usa xftp para subir a linux

4. Descomprimir

descomprimir experto

tar -zxvf apache-maven-3.8.5-bin.tar.gz

renombrar-maven

mv apache-maven-3.8.5-bin.tar.gz apache-maven-3.8.5

descomprimir jdk

tar -zxvf jdk-8u333-linux-x64.tar.gz

renombrar jdk

mv jdk-8u333-linux-x64.tar.gz jdk1.8

5. Configurar variables de entorno

Introduzca el archivo de variables de entorno

vim /etc/profile

Agregue la entrada de configuración jdk y manveni , ingrese al modo de entrada

Preste atención a su directorio de instalación, simplemente colóquelo en la parte superior del archivo

JAVA_HOME=/usr/local/java/jdk1.8
CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
PATH=$JAVA_HOME/bin:$PATH
export JAVA_HOME CLASSPATH PATH
export MAVEN_HOME=/usr/local/java/apache-maven-3.8.5
export PATH=${MAVEN_HOME}/bin:${
    
    PATH}

Presione esc, ingrese para :wqguardar y salir.

Comprobar si la instalación es exitosa

java -version

mvn -v

6. Configurar la imagen acelerada de Maven

cd apache-maven-3.8.5/conf/

vim settings.xml

entrada i, entrar en el modo de entrada

<mirrors>
	<mirror>
	    <id>alimaven</id>
	    <name>aliyun maven</name>
	    <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
	    <mirrorOf>central</mirrorOf>
	</mirror>
</mirrors>

Presione esc, ingrese para :wqguardar y salir.

Cuarto, Docker instala Jenkins

1. Prepárese para montar el directorio

cd home/

mkdir jenkins_home

Asegúrese de otorgar permiso de modificación, de lo contrario, el montaje fallará, le damos el permiso más alto aquí.

chmod -R 777 jenkins_home

2. Ejecute el comando docker

docker run -di --name=myjenkins -p 8080:8080 -v /home/jenkins_home:/var/jenkins_home \
-v /usr/local/java/jdk:/usr/local/jdk1.8 \
-v /usr/local/java/apache-maven-3.8.5:/usr/local/apache-maven-3.8.5 \
-v $(which docker):/usr/bin/docker \
-v /var/run/docker.sock:/var/run/docker.sock jenkins/jenkins:lts

-v /home/jenkins_home:/var/jenkins_home: Es la carpeta que almacena información de configuración de Jenkins en el contenedor
-v /usr/local/java/jdk:/usr/local/jdk1.8: Es la asociación entre jdk en Linux y el contenedor (usado al configurar Jenkins)
-v /usr/local/java/apache-maven-3.8.5:/usr/local/apache-maven-3.8.5: Es la asociación entre maven en linux y el contenedor (usado al configurar Jenkins )

-v $(which docker):/usr/bin/docker -v /var/run/docker.sock:/var/run/docker.sock: Es posible usar nuestra ventana acoplable bajo Linux en el contenedor de Jenkins.

5. Configurar Jenkins

1. Entra Jenkins

Entrada: http://192.168.84.133:8080/(ip+número de puerto)

2. Obtener contraseña

docker logs 容器id

3. Instala el complemento

4. Crear usuario

5. Guarde la dirección de configuración

6. Configurar la duplicación de complementos

ingresar:https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json

haga clic en enviar

7. Instala el complemento ssh

Una vez completada la instalación, reinicie Jenkins

8. Agregar credenciales de cuenta de inicio de sesión ssh

Haga clic 系统管理para encontrar la imagen de abajo

9. Configurar ssh global

haga clic 系统管理para encontrar系统配置

Haga clic para agregar:

Clic en Guardar:

10. Configurar jdk y maven

Haga clic 系统管理para encontrar 全局工具配置:

clic en Guardar

6. Prepara el proyecto Springboot para git

1. Código central

Vemos que es solo una solicitud para imprimir, y tenemos la última visita docker成功, lo que significa que hemos construido y enviado correctamente el paquete.

2. contenido pom

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <executions>
                <execution>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <includeSystemScope>true</includeSystemScope>
            </configuration>
        </plugin>
    </plugins>
</build>

3. archivo yml

Aquí solo se especifica el número de puerto

server.port=8081

4. Archivo acoplable

Mismo nivel que el archivo pom

FROM java:8

COPY *.jar /app.jar

CMD ["--server.port=8080"]

EXPOSE 8080

ENTRYPOINT ["java", "-jar", "/app.jar"]

5. Sube el repositorio de git

7. Usa Jenkins para implementar el proyecto

1. Crea una nueva tarea

2. Agregue credenciales de git

Seleccione las credenciales recién agregadas y el mensaje de error desaparecerá

3. Agregar compilación experta

4. Agregar shell de ejecución de compilación

guión de shell:

#!/bin/bash
# 服务名称
SERVER_NAME=jenkins

# 源jar名称，mvn打包之后，target目录下的jar包名称
JAR_NAME=demo-0.0.1-SNAPSHOT

# jenkins下的目录
JENKINS_HOME=/var/jenkins_home/workspace/jenkins

# 等待三秒
echo sleep 3s
sleep 1
echo sleep 2s
sleep 1
echo sleep 1s
sleep 1
      
echo "结束进程完成"

cd $JENKINS_HOME/target

cp $JENKINS_HOME/Dockerfile $JENKINS_HOME/target

# 修改文件权限
chmod 755 $JAR_NAME.jar

echo "看看docker能不能用"
docker -v

echo "停止容器"
# 停止容器
docker stop springboot

echo "删除容器"
# 删除容器
docker rm springboot
echo "删除镜像"
# 删除镜像
docker rmi springboot
echo "打包镜像"
# 打包镜像
docker build -t springboot .
echo "运行镜像"
# 运行镜像
docker run -d -p 8081:8081 --name springboot springboot

5. Construir ahora

6. Error de salida de la consola

Vemos que el empaquetado es exitoso, pero hay un problema de permisos al usar el comando docker ¡Esto se soluciona dando permiso a docker.sock! !

Mensaje de error:

Got permission denied while trying to connect to the Docker daemon socket at
 unix:///var/run/docker.sock: Post 
 "http://%2Fvar%2Frun%2Fdocker.sock/v1.24/containers/springboot/stop": dial unix 
 /var/run/docker.sock: connect: permission denied

solución:

chmod a+rw /var/run/docker.sock

7. En subconstrucción

Descubrimos que no se informó ningún error y también vimos la identificación del contenedor.

8. Consulta si la imagen de la ventana acoplable está iniciada

docker images

docker ps

9. Win10 para prueba de acceso

Ingresa la direccion:http://192.168.84.133:8081/test/docker

7. Resumen

El editor ha estado estudiando de forma intermitente durante una semana, no es fácil y hay muchas trampas en el medio, siempre que siga al editor, ¡básicamente puede salir!
Si ve esto, ¡no le dé al editor un botón para conectarse tres veces! ! Gracias a todos ~

---

¡Aquellos que están destinados pueden verlo! ! !

Haga clic para visitar! ¡El propio sitio web del editor también tiene muchos buenos artículos!