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()