Cree rápidamente una imagen del proyecto SpringBoot basada en Fabric8 y publíquela en el tutorial detallado de k8s

Others 2020-09-22 12:43:00 views: null

Prefacio

En el ecosistema de computación en la nube predominante, Docker ha liderado la tendencia de la tecnología de contenedorización desde su lanzamiento. Docker es muy adecuado para administrar un solo contenedor. Pero si nuestro sistema de aplicaciones distribuidas está compuesto por múltiples contenedores, a medida que el sistema evoluciona iterativamente, se utilizan cada vez más contenedores y aplicaciones en contenedores, y se dividen en números debido a la alta concurrencia y alta disponibilidad. Es probable que cientos de piezas dificulten mucho la gestión y el diseño. Necesitamos con urgencia agrupar contenedores para proporcionar servicios como redes, almacenamiento, seguridad y telemetría en todos los contenedores, por lo que Kubernetes nació.

Introducción a Kubernetes

Kubernetes, también conocido como k8s o "kube" para abreviar, es una plataforma de código abierto que puede implementar automáticamente operaciones de contenedor de Linux. Puede ayudar a los usuarios a guardar muchas operaciones de implementación y expansión manuales en el proceso de contenedorización de aplicaciones. En otras palabras, puede reunir varios grupos de hosts que ejecutan contenedores de Linux juntos, y Kubernetes puede ayudarlo a administrar estos clústeres de manera fácil y eficiente. Además, estos clústeres pueden implementar hosts en nubes públicas, privadas o híbridas. Por lo tanto, para las aplicaciones nativas de la nube que requieren una expansión rápida (como el procesamiento de flujo de datos en tiempo real con Apache Kafka), Kubernetes es una plataforma de alojamiento ideal.

La forma tradicional de publicar aplicaciones SpringBoot en K8

A medida que la tecnología de k8s continúa madurando y gradualmente se convierte en la corriente principal de la administración de aplicaciones, en lo que respecta a las aplicaciones SpringBoot, cómo lanzar la aplicación a la plataforma k8s requiere los siguientes pasos:

imagen-20200718225935393

En estos pasos, el equipo debe tener la capacidad de crear imágenes de Docker y capacidades de configuración de k8s, que son más difíciles de implementar, y debe administrar la configuración de Docker y la configuración de k8s por separado. Para los desarrolladores o colegas responsables del lanzamiento, la publicación de aplicaciones no es un simple clic. ser capaz de obtener algo, decimos que vamos a hacer la agilidad, lo haremos DevOps, integración continua, Docker以及k8s都是好技术，但是过于麻烦且不简单的步骤，确实是大部分公司或者项目想转型DevOps的门槛。y más tarde jenkinsapareció, la aparición de automatizada línea de montaje, así que no puedo evitar pensar 第一次工业革命, realmente ha mejorado la productividad, que finalmente no tenemos que cada vez que ssh, sftp, docker build, kubectl apply...

惊å '† ï¼ ??

工业革命¿Es suficiente confiar en los scripts para la ejecución automatizada por primera vez ?

è¿˜ä¸ ?? 够

Necesitamos reducir aún más la dificultad de la construcción del proyecto SpringBoot de la configuración de Docker y la configuración de k8s, de modo que incluso un desarrollador que no es muy bueno en la construcción de imágenes de Docker y la construcción de aplicaciones k8s pueda realizar rápidamente el lanzamiento de un comando de proyecto. En esta era, lo llamo Como la "Segunda Revolución Industrial".

La herramienta clave de esta era es ----Fabric8

Introducción a Fabric8

Fabric es la palabra a la que me enfrento todos los días, que se dedica a blockchain, y ocasionalmente cuando visito github, me encuentro con un amigo Fabric8 que es similar a él.

¿Qué es Fabric8?

Fabric8 es una plataforma de desarrollo integrada de código abierto que proporciona un lanzamiento continuo para microservicios basados ​​en Kubernetes y Jenkins .

Con fabric, puede crear, compilar, implementar y probar microservicios fácilmente a través de canalizaciones de Entrega continua , y luego ejecutarlos y administrarlos a través de Mejora continua y ChatOps .

La plataforma de microservicios Fabric8 proporciona:

Introducción de texto

En este artículo, basado en el complemento maven proporcionado por fabric8, la aplicación springboot se publicará rápidamente en k8s a través de la configuración del archivo pom.xml.

práctica

Preparación ambiental

Entorno / dependencia del sistema versión Observaciones
Ubuntu16.04 16.04 Sistema de entorno de desarrollo / compilación
Java 1.8
SpringBoot 2.1
Maven 3.3.9
k8s 1.16.1
fabric8-maven-plugin 4.0.0 https://github.com/fabric8io/fabric8-maven-plugin
estibador 18.04

Configuración de ingeniería

En primer lugar, fabric8-maven-plugin, como complemento de maven, no tiene introducción al código de la aplicación, por lo que básicamente todas las aplicaciones de ingeniería de springboot pueden agregar directamente la configuración del complemento de maven en el POM para lograr la aplicación de un comando que se publicará en k8s.

A continuación, hablaré sobre el método de configuración predeterminado de fabric8-maven-plugin , el método de configuración basado en xml y el método de configuración de archivos externos para ayudarnos a publicar la aplicación Springboot directamente en k8s.

Configuración predeterminada

El método de configuración predeterminado, como su nombre lo indica, es no realizar ningún procesamiento personalizado, y la implementación es la siguiente:

  1. Editar pom.xml
 <plugin>
      <groupId>io.fabric8</groupId>
      <artifactId>fabric8-maven-plugin</artifactId>
      <version>${fabric8.maven.plugin.version}</version>
      <executions>
          <execution>
             <goals>
                <goal>resource</goal>
                <goal>build</goal>
                </goals>
            </execution>
     </executions>
                             
    </plugin>

  1. Publicar la aplicación en k8s

    Generalmente mi operación es

    mvn fabric8:deploy

    Luego construya el espejo y publique la aplicación en k8s y listo.

    El siguiente es el registro principal ejecutado por mvn

    [INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ test ---
[INFO] Building jar: /home/lps/servers/jenkins/workspace/test-pipe1/target/test-2.0.2.RELEASE.jar
[INFO] 
[INFO] --- sofa-ark-maven-plugin:1.1.1:repackage (default-cli) @ test ---
[INFO] 
[INFO] --- spring-boot-maven-plugin:1.4.2.RELEASE:repackage (default) @ test ---
[INFO] 
[INFO] --- fabric8-maven-plugin:4.3.1:build (default) @ test ---
[INFO] F8: Pulling from java-alpine-openjdk8-jdk
[INFO] F8: Digest: sha256:e8a8e8f5fcd3b545c48ade9ab5716e9414c6f60a60f07a388ff9fafbd
[INFO] F8: Status: Downloaded newer image for registry.testdemo.com/java-alpine-openjdk8-jdk:latest
[INFO] F8: Pulled registry.testdemo.com/java-alpine-openjdk8-jdk:latest in 588 milliseconds
[INFO] Reading assembly descriptor: /home/lps/servers/jenkins/workspace/test-pipe1/src/main/docker/assembly.xml
[INFO] Copying files to /home/lps/servers/jenkins/workspace/test-pipe1/target/docker/testdemo/test/2.0.2.RELEASE/build/maven
[INFO] Building tar: /home/lps/servers/jenkins/workspace/test-pipe1/target/docker/testdemo/test/2.0.2.RELEASE/tmp/docker-build.tar
[INFO] F8: [testdemo/test:2.0.2.RELEASE]: Created docker-build.tar in 2 seconds 
[INFO] F8: [testdemo/test:2.0.2.RELEASE]: Built image sha256:486a1
[INFO] 
[INFO] --- maven-install-plugin:2.4:install (default-install) @ test ---
[INFO] Installing /home/lps/servers/jenkins/workspace/test-pipe1/target/test-2.0.2.RELEASE.jar to /root/.m2/repository/com/testdemo/test/2.0.2.RELEASE/test-2.0.2.RELEASE.jar
[INFO] Installing /home/lps/servers/jenkins/workspace/test-pipe1/pom.xml to /root/.m2/repository/com/testdemo/test/2.0.2.RELEASE/test-2.0.2.RELEASE.pom
[INFO] Installing /home/lps/servers/jenkins/workspace/test-pipe1/target/classes/META-INF/fabric8/kubernetes.yml to /root/.m2/repository/com/testdemo/test/2.0.2.RELEASE/test-2.0.2.RELEASE-kubernetes.yml
[INFO] Installing /home/lps/servers/jenkins/workspace/test-pipe1/target/classes/META-INF/fabric8/openshift.yml to /root/.m2/repository/com/testdemo/test/2.0.2.RELEASE/test-2.0.2.RELEASE-openshift.yml
[INFO] Installing /home/lps/servers/jenkins/workspace/test-pipe1/target/test-2.0.2.RELEASE-sources.jar to /root/.m2/repository/com/testdemo/test/2.0.2.RELEASE/test-2.0.2.RELEASE-sources.jar
[INFO] Installing /home/lps/servers/jenkins/workspace/test-pipe1/target/classes/META-INF/fabric8/kubernetes.yml to /root/.m2/repository/com/testdemo/test/2.0.2.RELEASE/test-2.0.2.RELEASE-kubernetes.yml
[INFO] Installing /home/lps/servers/jenkins/workspace/test-pipe1/target/classes/META-INF/fabric8/openshift.yml to /root/.m2/repository/com/testdemo/test/2.0.2.RELEASE/test-2.0.2.RELEASE-openshift.yml
[INFO] Installing /home/lps/servers/jenkins/workspace/test-pipe1/target/test-2.0.2.RELEASE-sources.jar to /root/.m2/repository/com/testdemo/test/2.0.2.RELEASE/test-2.0.2.RELEASE-sources.jar
[INFO] 
[INFO] <<< fabric8-maven-plugin:4.3.1:deploy (default-cli) < install @ test <<<
[INFO] 
[INFO] 
[INFO] --- fabric8-maven-plugin:4.3.1:deploy (default-cli) @ test ---
[INFO] F8: Using Kubernetes at https://localhost:6443/ in namespace baas-test with manifest /home/lps/servers/jenkins/workspace/test-pipe1/target/classes/META-INF/fabric8/kubernetes.yml 
[INFO] F8: Using namespace: baas-test
[INFO] F8: Using namespace: baas-test
[INFO] F8: Updating a Service from kubernetes.yml
[INFO] F8: Updated Service: target/fabric8/applyJson/baas-test/service-test.json
[INFO] F8: Using namespace: baas-test
[INFO] F8: Updating ConfigMap from kubernetes.yml
[INFO] F8: Updated ConfigMap: target/fabric8/applyJson/baas-test/configmap-test-config.json
[INFO] F8: Using namespace: baas-test
[INFO] F8: Updating Deployment from kubernetes.yml
[INFO] F8: Updated Deployment: target/fabric8/applyJson/baas-test/deployment-test.json
[WARNING] Error reading service account token from: [/var/run/secrets/kubernetes.io/serviceaccount/token]. Ignoring.
[INFO] F8: HINT: Use the command `kubectl get pods -w` to watch your pods start up
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

    En el registro anterior, podemos ver que un fabric8: deploy en realidad tiene los siguientes pasos:

    imagen-20200718234641209

Lo anterior es la operación específica de la configuración por defecto. Es muy conveniente configurar el pom.xml y ejecutar el comando mvn. La ejecución del comando mvn se puede colocar en jenkins. Y fabric8 viene con 3 espejos básicos, a saber:

Nombre del espejo descripción
fabric8 / java-alpine-openjdk8-jdk Basado en un sistema apline con imagen básica java8
fabric8 / java-jboss-openjdk8-jdk Basado en el sistema jboss con java8 basic mirror
fabric8 / java-centos-openjdk8-jdk Basado en el sistema centos con imagen básica java8

默认是使用第一个镜像，其他两个以及自定义基础镜像可以通过后面的配置自定义化。

Basado en la configuración xml

El método de configuración basado en xml es principalmente para realizar la personalización de la construcción de la imagen de la ventana acoplable y la configuración de lanzamiento de k8s (implementación, servicio, mapa de configuración), como se mencionó anteriormente, cómo usar mi propia imagen como la imagen base para la construcción de la aplicación

La implementación es la siguiente:

 <plugin>
                <groupId>io.fabric8</groupId>
                <artifactId>fabric8-maven-plugin</artifactId>
                <version>${fabric8.maven.plugin.version}</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>resource</goal>
                            <goal>build</goal>
                        </goals>
                    </execution>
                </executions>
     <!-- 自定义配置 -->
                <configuration>
                    <enricher>
                        <config>
                            <!-- k8s service 配置 将service开放类型改成NodePort  -->
                            <fmp-service>
                                <type>NodePort</type>
                            </fmp-service>
                        </config>
                    </enricher>
                    <images>
                        <image>
                            <!-- 自定义镜像名 -->
                            <name>lps/${project.artifactId}:${project.version}</name>
						
                            <build>
                                <!-- 自定义基础镜像-->
                                <from>registry.lps.com/fabric-base-jdk8</from>
                                <!-- 自定义文件发布 比如将项目 a-jarwithdepences.jar发布到镜像目录/deployment / -->
                                <assembly>
                                    <descriptor>assembly.xml</descriptor>
                                    <targetDir>/deployments</targetDir>
                                </assembly>

                            </build>
                        </image>
                    </images>

                </configuration>
            </plugin>

Varias configuraciones de uso común se proporcionan arriba. Para más configuraciones xml, consulte: https://maven.fabric8.io/#xml-configuration

Configuración basada en archivos externos

Basado en un archivo de configuración externo es una configuración externa que usa src/main/fabric8la configuración YAML ubicada en el directorio.

El catálogo principal de proyectos es el siguiente

├── README.md
├── pom.xml
└── src
    ├── main
    │   └── java 
    │   └── resource
    │   └── fabric8
             ├── service.yml 
             ├── deployment.yml 
             ├── configmap.yml

Principalmente src/main/fabric8, los tres archivos en el directorio corresponden principalmente a la configuración de implementación, servicio y mapa de configuración de k8s. Fabric8-maven-plugin leerá automáticamente los archivos en este directorio al compilar y generará la configuración de acuerdo con los parámetros definidos por el archivo (el complemento en sí tiene valores predeterminados Configuración, la configuración personalizada solo necesita modificar la parte personalizada y el resto se generará automáticamente)

La plantilla es la siguiente:

deployment.yml

spec:
  replicas: 1
  template:
    spec:
      volumes:
        - name: config
          gitRepo:
            repository: 'https://github.com/jstrachan/sample-springboot-config.git'
            revision: 667ee4db6bc842b127825351e5c9bae5a4fb2147
            directory: .
      containers:
        - volumeMounts:
            - name: config
              mountPath: /app/config
          env:
            - name: KUBERNETES_NAMESPACE
              valueFrom:
                fieldRef:
                  apiVersion: v1
                  fieldPath: metadata.namespace
      serviceAccount: ribbon

La configuración de volúmenes, contenedores y serviceAccont se personaliza arriba, y el resto de la configuración se generará de acuerdo con la plantilla predeterminada.

La personalización de la configuración se puede lograr de esta manera, que se puede utilizar en combinación con xml.

Resumen de comandos de fabric8 mvn

fabric8: construir

Crear imagen

utilizar:

mvn  fabric8:build

fabric8: empujar

Espejo de empuje

utilizar:

mvn  fabric8:push

Para enviar a un almacén privado, debe settings.xmlconfigurar la contraseña de la URL del almacén en el archivo de configuración de maven

ejemplo

<?xml version="1.0"?>
<settings>

  <profiles>
    <profile>
      <id>mydocker</id>
      <properties>
          <!-- 配置docker host/仓库地址 通过环境变量获取-->
        <docker.registry>${env.DOCKER_REGISTRY}</docker.registry>
        <docker.url>${env.DOCKER_HOST}</docker.url>
      </properties>
    </profile>
  </profiles>
<!-- 配置用户名密码 -->
   <servers>
       <server>
           <id>mydocker</id>
           <username>jolokia</username>
           <password>jolokia</password>
       </server>
        
  </servers>

  <activeProfiles>
    <activeProfile>mydocker</activeProfile>
  </activeProfiles>
</settings>

fabric8: implementar

Publicar la aplicación en k8s

1. Establecer variables de entorno

export KUBERNETES_TRUST_CERTIFICATES=true \
&& export KUBERNETES_MASTER=${KUBERNETES_MASTER} \
&& export FABRIC8_PROFILES=kubernetes \ 
&& export DOCKER_HOST=${DOCKER_HOST} \
&& export KUBERNETES_NAMESPACE=${KUBERNETES_NAMESPACE} \
  • $ {KUBERNETES_MASTER}: la dirección API del maestro en la red k8s, como: http: // localhost: 6443
  • $ {DOCKER_HOST}: dirección de servicio DOCKER como: http: // localhost: 2375
  • $ {KUBERNETES_NAMESPACE}: el espacio de nombres de k8s donde se publica la aplicación, como: prueba

2. Ejecute el comando

 mvn fabric8:deploy

fabric8: recurso

src/main/fabric8Genere un archivo de configuración de k8s de acuerdo con el archivo yml personalizado en el directorio, que generalmente se usa para verificar si el yml generado tiene una configuración personalizada efectiva

 mvn fabric8:resource

para resumir

El plugin fabric8-maven debería ser una de las mejores soluciones para publicar proyectos springboot en k8s en la actualidad. Reduce en gran medida la dificultad de construir la configuración, e incluso se puede realizar un solo comando desde un proyecto springboot a un servicio que se ejecuta en k8s, por lo que Lo recomiendo altamente.

Si hay un plan mejor, puedes comentar a los pequeños.

Supongo que te gusta

Origin blog.csdn.net/qq_28540443/article/details/107437916
Recomendado
Clasificación
Diario
Más
2024-05-08(18)
2024-05-07(35)
2024-05-06(4)
2024-05-05(0)
2024-05-04(17)
2024-05-03(8)
2024-05-02(0)
2024-05-01(4)
2024-04-30(33)
2024-04-29(5)

Code World

© 2018 codetd.com