Red de conocimiento informático - Conocimiento informático - Cómo implementar una aplicación Spring Boot

Cómo implementar una aplicación Spring Boot

Instalación de Java8 en Ubuntu

A continuación se muestra un proceso de instalación sencillo.

$ sudo add-apt-repository ppa:webupd8team/java

$ sudo apt-get update

$ sudo apt-get install oracle-java8-installer

$ java -version

versión de Java "1.8.0_60"

Java(TM) SE Runtime Environment (compilación 1.8.0_60-b27)

Máquina virtual de servidor Java HotSpot(TM) de 64 bits (compilación 25.60-b23, modo mixto)

2. Utilice Gradle para publicar aplicaciones Spring Boot localmente

Soy Jetty9 se utiliza aquí como servidor integrado.

// ...

bootRun {

systemProperties = System.properties

}

configuraciones {

módulo compilar.exclude: "spring-boot-starter-tomcat"

}

dependencias {

// spring boot

compilar "org.springframework.boot:spring-boot-starter-web:1.3.0.M5"

compilar "org.springframework.boot:spring-boot-starter-jetty "

// ...

}

//...

De forma predeterminada, se utiliza src/main/resources cuando se ejecuta localmente /application.yml como un archivo de configuración, y en un entorno de producción, nuestro sistema admite el suministro de un archivo de configuración externo application-production.yml. /gradlew bootRun # En el entorno de desarrollo, usamos el archivo application.yml en el proyecto de forma predeterminada

# En las pruebas locales, usamos archivos de configuración externos

.

/gradlew bootRun -Dspring.config.location=/path/to/application-production.yml?

# Publicar

.

# Ejecutar

java -jar build/libs/SpringBlog-0.1.jar ?# De forma predeterminada, se utiliza el archivo de configuración application.yml en el paquete jar

# Utilice un archivo de configuración externo

java - jar build/libs/SpringBlog-0.1.jar --spring.config.location=/path/to/ application-production.yml

3. server

# Cargue SpringBlog-0.1.jar al servidor

scp build/libs/SpringBlog-0.1.jar1 jar root@your_server_ip:/root/spring-blog/current<. /p>

# Configure el archivo de configuración del entorno de producción en el servidor

scp application-production.yml root@your_server_ip:/root/spring-blog/current

Luego inicie sesión Ingrese al servidor a través de SSH y modifique el archivo de configuración application-production.yml e intente ejecutar la aplicación.

ssh root@your_server_ip

cd spring-blog/current

java -jar SpringBlog-0.1.jar --spring.config.location=aplicación-producción .yml

# application-production.yml

servidor:

dirección: rayosmond.com # Después del inicio, use el nombre de dominio o IP para acceder al sitio web

puerto: 80

contextPath:

primavera:

perfiles:

activo: producción

thymeleaf:

caché: verdadero

jade4j:

almacenamiento en caché: verdadero

fuente de datos:

driverClassName: com. mysql.jdbc.Driver:

url: jdbc:mysql://127.0.0.1/spring_blog

Nombre de usuario: root

Contraseña:

hibernar:

dialecto: org.hibernate.dialect.MySQLDialect

hbm2ddl.auto: actualizar

show_sql: falso

redis:

host: localhost

puerto: 6379

4. ¿Cómo ejecutar la aplicación Spring Boot en segundo plano de Ubuntu?

El comando recomendado es nohup.

cd /root/spring-blog/current

nohup java -jar SpringBlog-0.1.jar --spring.config.location=application-production.yml\

> ./logs/production.log 2> .../logs/production.err &

En Ubuntu, también puede crear un nuevo script en el directorio /etc/init.d, Ejecute SpringBlog como un servicio para no tener que escribir comandos tan tediosos cada vez.

Cree un nuevo archivo /etc/init.d/spring_blog con el siguiente contenido:

#! /bin/sh

SERVICE_NAME=spring_blog

HOME=/root/spring-blog

PATH_TO_JAR=$HOME/current/SpringBlog-0.1.jar

PID_ PATH_NAME=/tmp/spring_blog.pid

LOG=$HOME/logs/production.

ERROR_LOG=$HOME/logs/production.err

CONFIG=$HOME/ application-production.yml

case $1 in

start)

echo "Iniciando $SERVICE_NAME ..."

if [ ! -f $PID_PATH_NAME ]; entonces

cd $HOME/current

nohup java -jar $PATH_TO_JAR --spring.config.location=aplicación -production.yml > ; $LOG 2> $ERROR_LOG &

echo $! > $PID_PATH_NAME

echo "$SERVICE_NAME iniciado..."

else

echo "$SERVICE_NAME ya se está ejecutando..."

fi

;;

detener)

if [ -f $PID_PATH_NAME ]; entonces

PID=$(cat $PID_PATH_NAME);

echo "$SERVICE_NAME se está deteniendo..."

kill $PID;

echo "$SERVICE_NAME se ha detenido..."

rm $PID_PATH_NAME

else

echo "$SERVICE_NAME no se ha ejecutado..."

fi

;;

reiniciar)

if [ -f $PID_PATH_NAME ]; entonces

PID=$(cat $PID_PATH_NAME);

echo "$SERVICE_NAME deteniéndose ...";

elimina $PID;

echo " $SERVICE_NAME detenido..." ;

rm $PID_PATH_NAME

echo "$SERVICE_NAME iniciando..."

cd $HOME/current

nohup java -jar $PATH_TO_JAR --spring.config.location=application-production.yml> $LOG 2> $ERROR_LOG & amp;

echo $ > $PID_PATH_NAME

echo "$SERVICE_NAME comenzó..."

else

echo "$SERVICE_NAME no se ejecutó..."

fi

<

p>;;

esac

Ahora es el momento de ejecutar el sitio web utilizando el servicio.

sudo service spring_blog start

sudo service spring_blog stop

sudo service spring_blog restart

5. Implementar automáticamente el sitio web local en el remoto. server

A nivel local, utilicé scripts de shell y scripts de Python para la implementación automática.

deploy.sh usa el comando gradle para publicar el paquete jar y usa el comando scp para cargarlo en el servidor

deploy.py usa SSH para iniciar sesión de forma remota en el servidor; y ejecute el comando de implementación en el servidor.

#deploy.sh

#! /bin/bash

SERVER="your_server_ip"

JAR="build/libs/SpringBlog-0.1.jar"

echo "Construyendo $JAR.. ."

.

./gradlew build

echo "Subir $JAR al servidor $SERVER..."

scp = "build/lib/SpringBlog-0.1 jar"

.

scp $JAR root@$SERVER:/root/spring-blog/

python implementar. py

deploy.py utiliza principalmente la biblioteca paramiko para iniciar sesión remotamente en el servidor a través de SSH y ejecutar comandos. Este script hará una copia de seguridad de /root/spring-blog/current/SpringBlog-0.1.jar en el servidor en /root/spring-blog/releases y colocará el paquete jar recién lanzado en /root/spring-blog/current. reinicie el servicio spring_blog.

¡Copia todo el proceso en el comentario #! /usr/bin/python

importar paramiko

importar subprocesos

importar hora

ip = 'your_server_ip'

usuario = 'root'

contraseña = ''

jar = 'SpringBlog-0.1.jar'

home='/root/spring-blog '

current=home+"/current"

releases=home+"/ releases"

def ejecutar_cmds(ip, usuario, contraseña, cmd):

p>

intenta:

ssh = paramiko.SSHClient()