Cómo implementar Spring Boot automáticamente en el servidor Ubuntu 14.04
El siguiente es un proceso de instalación simple.
$ 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"
Entorno de ejecución Java(TM) SE (compilación 1.8.0_60-b27)
p>
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
I Jetty9 se utiliza aquí como servidor integrado.
// ...
bootRun {
systemProperties = System.properties
}
configuraciones {
módulo compile.exclude: "spring-boot-starter-tomcat"
}
dependencias {
// spring boot
compila "org.springframework.boot: spring-boot-starter-web: 1.3.0.M5"
compila "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
# Lanzamiento
.
/gradlew build
# 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
# Usar archivos de configuración externos
java -jar build/libs/SpringBlog-0.1.jar --spring.config.location=/path/to/application-production.yml
3. Implemente la aplicación Spring Boot en el servidor Ubuntu
# Cargue SpringBlog-0.1.jar al servidor
Cargue 4.jar al servidor
<. p>scp build/ libs/SpringBlog-0.1.jar root@your_server_ip：/root/spring-blog/current# Configure el entorno de producción en el servidor usando el archivo de configuración en el servidor
scp application-production .yml root@your_server_ip：/root/spring-blog/current
Luego inicie sesión en el servidor a través de SSH y modifique el archivo de configuración application-production.yml.
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:
spring:
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: false
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\
gt; ./logs/production.log 2gt; .../logs/production.err amp;
En Ubuntu, también puedes crear uno en el directorio /etc/init.d Nuevo script que ejecuta SpringBlog como un servicio para que no tenga 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 en
inicio)
echo "Iniciando $SERVICE_NAME ..."
if [ ! -f $PID_PATH_NAME ]; entonces
cd $HOME/current
nohup java -jar $PATH_TO_JAR --spring.config.location=aplicación -producción.yml gt; $LOG 2gt; $ERROR_LOG amp;
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 deteniéndose..."
matar $PID_PATH_NAME....
matar $PID;
echo "$SERVICE_NAME detenido ..."
rm $PID_PATH_NAME
else
echo "$SERVICE_NAME no se está ejecutando ..."
fi
;;
reiniciar)
if [ -f $PID_PATH_NAME ]; entonces
PID=$(cat $PID_PATH_NAME);
echo "$SERVICE_NAME deteniéndose..." ;
kill $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=aplicación
n-production.yml gt; $LOG 2gt; $ERROR_LOG amp;
echo $! $PID_PATH_NAME
echo "$SERVICE_NAME iniciado...".
else
echo "$SERVICE_NAME no se está ejecutando..."
fi
;;
esac
Ahora es el momento de ejecutar el sitio como un 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
Localmente, utilicé scripts de shell y scripts de Python para la implementación automatizada.
implementar.sh usa el comando gradle para publicar el paquete jar y usa el comando scp para cargarlo en el servidor
implementar.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.
#! /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>
intente:
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect( ip, 22, usuario, contraseña, tiempo de espera = 5)
para m en cmd:
imprimir m
stdin, stdout, stderr = ssh.exec_command( m)
# stdin.write("Y")
salida = stdout.readlines()
para o entrada salida:
imprimir o,
imprimir 's\tOK\n'(ip)
ssh.close()
excepto :
print 's\tError\n'(ip)
if __name__=='__main__':
print 'Comenzar a implementar s en el servidor s'(jar, ip)
ahora = time.strftime("YmdHMS")
cmd = [
'echo Detener el servicio spring_blog... amp servicio spring_blog detener' ,
'echo Vaciar todos los datos de la caché de redis... amp; redis-cli -r 1 flushall',
'echo Detener el servidor de redis... amp; service redis_6379 stop ',
'echo Usar nuevo jar... ' \
' amp mv ' current '/' jar ' ' libera '/' ahora '_' jar; ,
'mv ' home '/' jar ' ' current '/' jar,
'echo Stop redis... amp service redis_6379 start',
'echo Iniciar spring_b
servicio de registro... servicio spring_blog start ' \
' echo Todo listo.
]
a=threading.Thread (target=execute_cmds, args=( ip, usuario, contraseña, cmd))
a.start()
Una vez completada la configuración, puede ejecutar el código localmente escribiendo el siguiente contenido. /deploy.sh implementa código en un servidor remoto.