阿里雲搭建伺服器部署springboot
① spring boot怎麼部署到伺服器
1. 既然需要打包成war包項目，首先需要在pom.xml文件中修改打包類型，將spring boot默認的<packaging>jar</packaging>修改為<packaging>war</packaging>形式；
2. 其次spring boot的web項目中內嵌tomcat伺服器，所以如果我們想要發布war包到tomcat項目，要講spring boot中內嵌的tomcat包依賴排除，不然產生沖突，打開下面代碼中的注釋即可。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<!--
<exclusions>
<exclusion>
② 求java大神：阿里雲伺服器重啟後springboot項目連接阿里雲上的Mysql資料庫失敗
看上去應該是MySQL連接自動斷開了的報錯，可以參考這個文章試試：網頁鏈接
③ springboot使用docker怎麼部署到伺服器
第一步：搭建springboot的web應用，可在CMD命令行中通過mvn install命令將應用打成jar包:如demo-0.0.1-SNAPSHOT.jar 第二步：將jar包到centos文件系統中，指定目錄示例為：/usr/local/demo-0.0.1-SNAPSHOT.jar
④ springboot怎麼配置伺服器
你可以像使用標準的Java庫文件一樣使用Spring Boot。簡單的將需要的 spring-boot-*.jar 添加到classpath即可。
Spring Boot不要求任何特殊的工具集成，所以可以使用任何IDE，甚至文本編輯器。
只是，仍然建議使用build工具：Maven 或 Gradle。
Spring Boot依賴 使用 org.springframework.boot groupId 。
⑤ 我用springboot寫了一個項目，分布式，然後只有一台伺服器，怎麼部署
只有一台伺服器的話，你可以開幾個tomcat，用不同的埠啟動，做分布式的模擬
⑥ Java CDN Spring boot
看看是否是nginx配置問題
⑦ 如何通過域名訪問阿里雲部署的springboot項
1、首先你要有個域名，阿里雲可以買
2、域名需要做解析，解析到你阿里雲的ip上
3、阿里雲控制台的防火牆和阿里雲伺服器（Linux）本身的防火牆都要打開 80 埠
4、springboot項目啟動時設置埠為 80 （獲取通過nginx轉發也可以）
⑧ 阿里雲的消息服務怎麼集成spring boot
如何使用Spring Boot/Spring Cloud 實現微服務應用
spring Cloud是一個基於Spring Boot實現的雲應用開發工具，它為基於JVM的雲應用開發中的配置管理、服務發現、斷路器、智能路由、微代理、控制匯流排、全局鎖、決策競選、分布式會話和集群狀態管理等操作提供了一種簡單的開發方式。
Spring Cloud與Dubbo對比
提到Dubbo，我想順便提下ESB，目前央視新華社也在用ESB來做任務編排，這里先比較下Dubbo和ESB：
ESB（企業數據匯流排），一般採用集中式轉發請求，適合大量異構系統集成，側重任務的編排，性能問題可通過異構的方式來進行規避，無法支持特別大的並發。
Dubbo（服務注冊管理），採用的是分布式調用，注冊中心只記錄地址信息，然後直連調用，適合並發及壓力比較大的情況；其側重服務的治理，將各個服務顆粒化，各個子業務系統在程序邏輯上完成業務的編排。
回歸主題，Spring Cloud和Dubbo又有什麼不同那，首先，我們看下有什麼相同之處，它們兩都具備分布式服務治理相關的功能，都能夠提供服務注冊、發現、路由、負載均衡等。說到這，Dubbo的功能好像也就這么多了，但是Spring Cloud是提供了一整套企業級分布式雲應用的完美解決方案，能夠結合Spring Boot，Docker實現快速開發的目的，所以說Dubbo只有Spring Cloud的一部分RPC功能，而且也談不上誰好誰壞。不過，Dubbo項目現已停止了更新，淘寶內部由hsf替代bbo，我想這會有更多人傾向Spring Cloud了。
從開發角度上說，Dubbo常與Spring、zookeeper結合，而且實現只是通過xml來配置服務地址、名稱、埠，代碼的侵入性是很小的，相對Spring Cloud，它的實現需要類註解等，多少具有一定侵入性。
⑨ 如何部署Spring Boot應用
在Ubuntu中安裝Java8
以下是一個簡單的安裝方法。
$ sudo add-apt-repository ppa:webupd8team/java
$ sudo apt-get update
$ sudo apt-get install oracle-java8-installer
$ java -version
java version "1.8.0_60"
Java(TM) SE Runtime Environment (build 1.8.0_60-b27)
Java HotSpot(TM) 64-Bit Server VM (build 25.60-b23, mixed mode)
2. 本地使用Gradle發布Spring Boot應用
我這里使用Jetty9作為內置的伺服器。
// ...
bootRun {
systemProperties = System.properties
}
configurations {
compile.exclude mole: "spring-boot-starter-tomcat"
}
dependencies {
// spring boot
compile "org.springframework.boot:spring-boot-starter-web:1.3.0.M5"
compile "org.springframework.boot:spring-boot-starter-jetty"
// ...
}
//...
在本地運行默認使用src/main/resources/application.yml作為配置文件，而在proction環境中我們系統它支持提供外部的配置文件application-proction.yml。
./gradlew bootRun # 開發環境下默認使用項目里的application.yml
# 在本地測試使用外部配置文件
./gradlew bootRun -Dspring.config.location=/path/to/application-proction.yml
# 發布
./gradlew build
# 運行
java -jar build/libs/SpringBlog-0.1.jar # 默認使用jar包裡面的application.yml配置文件
# 使用外部配置文件
java -jar build/libs/SpringBlog-0.1.jar --spring.config.location=/path/to/application-proction.yml
3. 在Ubuntu伺服器上部署Spring Boot應用
# 上傳SpringBlog-0.1.jar到伺服器
scp build/libs/SpringBlog-0.1.jar root@your_server_ip:/root/spring-blog/current
# 在伺服器上配置生產環境的配置文件
scp application-proction.yml root@your_server_ip:/root/spring-blog/current
然後SSH登錄伺服器，修改配置文件application-proction.yml，試運行應用。
ssh root@your_server_ip
cd spring-blog/current
java -jar SpringBlog-0.1.jar --spring.config.location=application-proction.yml
# application-proction.yml
server:
address: raysmond.com # 使用域名或者IP，啟動之後就可以這個域名或IP訪問網站了
port: 80
contextPath:
spring:
profiles:
active: proction
thymeleaf:
cache: true
jade4j:
caching: true
dataSource:
driverClassName: com.mysql.jdbc.Driver
url: jdbc:mysql://127.0.0.1/spring_blog
username: root
password:
hibernate:
dialect: org.hibernate.dialect.MySQLDialect
hbm2ddl.auto: update
show_sql: false
redis:
host: localhost
port: 6379
4. 如何在Ubuntu中後台運行Spring Boot應用？
推薦使用nohup這個命令。
cd /root/spring-blog/current
nohup java -jar SpringBlog-0.1.jar --spring.config.location=application-proction.yml
> ../logs/proction.log 2> ../logs/proction.err &
在Ubuntu還可以/etc/init.d目錄下新建一個腳本，把SpringBlog作為service來運行，這樣不用每次都打這么繁瑣的命令了。新建一個/etc/init.d/spring_blog文件，內容如下：
#!/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/proction.log
ERROR_LOG=$HOME/logs/proction.err
CONFIG=$HOME/application-proction.yml
case $1 in
start)
echo "Starting $SERVICE_NAME ..."
if [ ! -f $PID_PATH_NAME ]; then
cd $HOME/current
nohup java -jar $PATH_TO_JAR --spring.config.location=application-proction.yml > $LOG 2> $ERROR_LOG &
echo $! > $PID_PATH_NAME
echo "$SERVICE_NAME started ..."
else
echo "$SERVICE_NAME is already running ..."
fi
;;
stop)
if [ -f $PID_PATH_NAME ]; then
PID=$(cat $PID_PATH_NAME);
echo "$SERVICE_NAME stoping ..."
kill $PID;
echo "$SERVICE_NAME stopped ..."
rm $PID_PATH_NAME
else
echo "$SERVICE_NAME is not running ..."
fi
;;
restart)
if [ -f $PID_PATH_NAME ]; then
PID=$(cat $PID_PATH_NAME);
echo "$SERVICE_NAME stopping ...";
kill $PID;
echo "$SERVICE_NAME stopped ...";
rm $PID_PATH_NAME
echo "$SERVICE_NAME starting ..."
cd $HOME/current
nohup java -jar $PATH_TO_JAR --spring.config.location=application-proction.yml > $LOG 2> $ERROR_LOG &
echo $! > $PID_PATH_NAME
echo "$SERVICE_NAME started ..."
else
echo "$SERVICE_NAME is not running ..."
fi
;;
esac
現在就可以使用service的方式來運行網站了。
sudo service spring_blog start
sudo service spring_blog stop
sudo service spring_blog restart
5. 在本地自動化部署網站到遠程伺服器
在本地我用了一個shell腳本和一個python腳本來配合自動化部署。
deploy.sh 使用gradle的命令發布jar包，使用scp命令吧jar包上傳到伺服器上；
deploy.py 使用SSH遠程登錄伺服器，並在伺服器上執行部署命令。
# deploy.sh
#!/bin/bash
SERVER="your_server_ip"
JAR="build/libs/SpringBlog-0.1.jar"
echo "Building $JAR..."
./gradlew build
echo "Upload $JAR to server $SERVER..."
scp $JAR root@$SERVER:/root/spring-blog/
python deploy.py
deploy.py主要使用了一個paramiko庫，用於SSH遠程登錄伺服器，並執行命令。這個腳本會把伺服器上/root/spring-blog/current/SpringBlog-0.1.jar備份到/root/spring-blog/releases中，並把新發布的jar包放到/root/spring-blog/current中，然後重啟spring_blog服務。
全選復制放進筆記#!/usr/bin/python
import paramiko
import threading
import time
ip = 'your_server_ip'
user = 'root'
password = ''
jar = 'SpringBlog-0.1.jar'
home='/root/spring-blog'
current=home+"/current"
releases=home+"/releases"
def execute_cmds(ip, user, passwd, cmd):
try:
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(ip,22,user,passwd,timeout=5)
for m in cmd:
print m
stdin, stdout, stderr = ssh.exec_command(m)
# stdin.write("Y")
out = stdout.readlines()
for o in out:
print o,
print '%s OK '%(ip)
ssh.close()
except :
print '%s Error '%(ip)
if __name__=='__main__':
print 'Start deploying %s to server %s'%(jar, ip)
now = time.strftime("%Y%m%d%H%M%S")
cmd = [
'echo Stop spring_blog service... && service spring_blog stop',
'echo Flush all redis cache data... && redis-cli -r 1 flushall',
'echo Stop redis server... && service redis_6379 stop',
'echo Use new jar... ' +
' && mv ' + current + '/' + jar + ' ' + releases + '/' + now + '_' + jar ,
'mv ' + home + '/' + jar + ' ' + current + '/' + jar,
'echo Stop redis... && service redis_6379 start',
'echo Start spring_blog service... && service spring_blog start ' +
' && echo All done.'
]
a=threading.Thread(target=execute_cmds, args=(ip,user,password,cmd))
a.start()
配置完以後，在本地寫完代碼就可以運行./deploy.sh一鍵部署到遠程伺服器了。
⑩ 如何在Ubuntu 14.04伺服器上自動化部署Spring Boot的應用
1. 在Ubuntu中安裝Java8
以下是一個簡單的安裝方法。
$ sudo add-apt-repository ppa:webupd8team/java
$ sudo apt-get update
$ sudo apt-get install oracle-java8-installer
$ java -version
java version "1.8.0_60"
Java(TM) SE Runtime Environment (build 1.8.0_60-b27)
Java HotSpot(TM) 64-Bit Server VM (build 25.60-b23, mixed mode)
2. 本地使用Gradle發布Spring Boot應用
我這里使用Jetty9作為內置的伺服器。
// ...
bootRun {
systemProperties = System.properties
}
configurations {
compile.exclude mole: "spring-boot-starter-tomcat"
}
dependencies {
// spring boot
compile "org.springframework.boot:spring-boot-starter-web:1.3.0.M5"
compile "org.springframework.boot:spring-boot-starter-jetty"
// ...
}
//...
在本地運行默認使用 src/main/resources/application.yml
作為配置文件，而在proction環境中我們系統它支持提供外部的配置文件 application-proction.yml
。
./gradlew bootRun # 開發環境下默認使用項目里的application.yml
# 在本地測試使用外部配置文件
./gradlew bootRun -Dspring.config.location=/path/to/application-proction.yml
# 發布
./gradlew build
# 運行
java -jar build/libs/SpringBlog-0.1.jar # 默認使用jar包裡面的application.yml配置文件
# 使用外部配置文件
java -jar build/libs/SpringBlog-0.1.jar --spring.config.location=/path/to/application-proction.yml
3. 在Ubuntu伺服器上部署Spring Boot應用
# 上傳SpringBlog-0.1.jar到伺服器
scp build/libs/SpringBlog-0.1.jar root@your_server_ip:/root/spring-blog/current
# 在伺服器上配置生產環境的配置文件
scp application-proction.yml root@your_server_ip:/root/spring-blog/current
然後 SSH
登錄伺服器，修改配置文件 application-proction.yml
，試運行應用。
ssh root@your_server_ip
cd spring-blog/current
java -jar SpringBlog-0.1.jar --spring.config.location=application-proction.yml
# application-proction.yml
server:
address: raysmond.com # 使用域名或者IP，啟動之後就可以這個域名或IP訪問網站了
port: 80
contextPath:
spring:
profiles:
active: proction
thymeleaf:
cache: true
jade4j:
caching: true
dataSource:
driverClassName: com.mysql.jdbc.Driver
url: jdbc:mysql://127.0.0.1/spring_blog
username: root
password:
hibernate:
dialect: org.hibernate.dialect.MySQLDialect
hbm2ddl.auto: update
show_sql: false
redis:
host: localhost
port: 6379
4. 如何在Ubuntu中後台運行Spring Boot應用？
推薦使用 nohup
這個命令。
cd /root/spring-blog/current
nohup java -jar SpringBlog-0.1.jar --spring.config.location=application-proction.yml \
> ../logs/proction.log 2> ../logs/proction.err &
在Ubuntu還可以 /etc/init.d
目錄下新建一個腳本，把SpringBlog作為service來運行，這樣不用每次都打這么繁瑣的命令了。新建一個 /etc/init.d/spring_blog
文件，內容如下：
#!/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/proction.log
ERROR_LOG=$HOME/logs/proction.err
CONFIG=$HOME/application-proction.yml
case $1 in
start)
echo "Starting $SERVICE_NAME ..."
if [ ! -f $PID_PATH_NAME ]; then
cd $HOME/current
nohup java -jar $PATH_TO_JAR --spring.config.location=application-proction.yml > $LOG 2> $ERROR_LOG &
echo $! > $PID_PATH_NAME
echo "$SERVICE_NAME started ..."
else
echo "$SERVICE_NAME is already running ..."
fi
;;
stop)
if [ -f $PID_PATH_NAME ]; then
PID=$(cat $PID_PATH_NAME);
echo "$SERVICE_NAME stoping ..."
kill $PID;
echo "$SERVICE_NAME stopped ..."
rm $PID_PATH_NAME
else
echo "$SERVICE_NAME is not running ..."
fi
;;
restart)
if [ -f $PID_PATH_NAME ]; then
PID=$(cat $PID_PATH_NAME);
echo "$SERVICE_NAME stopping ...";
kill $PID;
echo "$SERVICE_NAME stopped ...";
rm $PID_PATH_NAME
echo "$SERVICE_NAME starting ..."
cd $HOME/current
nohup java -jar $PATH_TO_JAR --spring.config.location=application-proction.yml > $LOG 2> $ERROR_LOG &
echo $! > $PID_PATH_NAME
echo "$SERVICE_NAME started ..."
else
echo "$SERVICE_NAME is not running ..."
fi
;;
esac
現在就可以使用service的方式來運行網站了。
sudo service spring_blog start
sudo service spring_blog stop
sudo service spring_blog restart
5. 在本地自動化部署網站到遠程伺服器
在本地我用了一個shell腳本和一個python腳本來配合自動化部署。
deploy.sh
使用 gradle
的命令發布jar包，使用 scp
命令吧jar包上傳到伺服器上；
deploy.py
使用 SSH
遠程登錄伺服器，並在伺服器上執行部署命令。
# deploy.sh
#!/bin/bash
SERVER="your_server_ip"
JAR="build/libs/SpringBlog-0.1.jar"
echo "Building $JAR..."
./gradlew build
echo "Upload $JAR to server $SERVER..."
scp $JAR root@$SERVER:/root/spring-blog/
python deploy.py
deploy.py
主要使用了一個 paramiko
庫，用於 SSH
遠程登錄伺服器，並執行命令。這個腳本會把伺服器上 /root/spring-blog/current/SpringBlog-0.1.jar
備份到 /root/spring-blog/releases
中，並把新發布的jar包放到 /root/spring-blog/current
中，然後重啟 spring_blog
服務。
#!/usr/bin/python
import paramiko
import threading
import time
ip = 'your_server_ip'
user = 'root'
password = ''
jar = 'SpringBlog-0.1.jar'
home='/root/spring-blog'
current=home+"/current"
releases=home+"/releases"
def execute_cmds(ip, user, passwd, cmd):
try:
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(ip,22,user,passwd,timeout=5)
for m in cmd:
print m
stdin, stdout, stderr = ssh.exec_command(m)
# stdin.write("Y")
out = stdout.readlines()
for o in out:
print o,
print '%s\tOK\n'%(ip)
ssh.close()
except :
print '%s\tError\n'%(ip)
if __name__=='__main__':
print 'Start deploying %s to server %s'%(jar, ip)
now = time.strftime("%Y%m%d%H%M%S")
cmd = [
'echo Stop spring_blog service... && service spring_blog stop',
'echo Flush all redis cache data... && redis-cli -r 1 flushall',
'echo Stop redis server... && service redis_6379 stop',
'echo Use new jar... ' + \
' && mv ' + current + '/' + jar + ' ' + releases + '/' + now + '_' + jar ,
'mv ' + home + '/' + jar + ' ' + current + '/' + jar,
'echo Stop redis... && service redis_6379 start',
'echo Start spring_blog service... && service spring_blog start ' + \
' && echo All done.'
]
a=threading.Thread(target=execute_cmds, args=(ip,user,password,cmd))
a.start()
配置完以後，在本地寫完代碼就可以運行 ./deploy.sh
一鍵部署到遠程伺服器了。