在 Ubuntu 上自动化安装基本应用的方法

Posted 2023-04-17

参考技术A 一些用户，特别是新手，可能希望轻松快速地安装他们喜欢的每个应用。

-- Sk

默认安装的 Ubuntu 并未预先安装所有必需的应用。你可能需要在网上花几个小时或者向其他 Linux 用户寻求帮助才能找到并安装 Ubuntu 所需的应用。如果你是新手，那么你肯定需要花更多的时间来学习如何从命令行（使用 apt-get 或 dpkg）或从 Ubuntu 软件中心搜索和安装应用。一些用户，特别是新手，可能希望轻松快速地安装他们喜欢的每个应用。如果你是其中之一，不用担心。在本指南中，我们将了解如何使用名为 “Alfred” 的简单命令行程序在 Ubuntu 上安装基本应用。

Alfred 是用 Python 语言编写的自由、开源脚本。它使用 Zenity 创建了一个简单的图形界面，用户只需点击几下鼠标即可轻松选择和安装他们选择的应用。你不必花费数小时来搜索所有必要的应用程序、PPA、deb、AppImage、snap 或 flatpak。Alfred 将所有常见的应用、工具和小程序集中在一起，并自动安装所选的应用。如果你是最近从 Windows 迁移到 Ubuntu Linux 的新手，Alfred 会帮助你在新安装的 Ubuntu 系统上进行无人值守的软件安装，而无需太多用户干预。请注意，还有一个名称相似的 Mac OS 应用，但两者有不同的用途。

Alfred 安装很简单！只需下载脚本并启动它。就这么简单。

或者，使用 wget 下载脚本，如上所示，只需将 alfred.py 移动到 $PATH 中：

使其可执行：

并使用命令启动它：

按照上面所说启动 Alfred 脚本。这就是 Alfred 默认界面的样子。

如你所见，Alfred 列出了许多最常用的应用类型，例如：

你可以选择任何一个或多个应用并立即安装它们。在这里，我将安装 “Developer bundle”，因此我选择它并单击 OK 按钮。

现在，Alfred 脚本将自动你的 Ubuntu 系统上添加必要仓库、PPA 并开始安装所选的应用。

安装完成后，你将看到以下消息。

恭喜你！已安装选定的软件包。

你可以使用以下命令 在 Ubuntu 上查看最近安装的应用 ：

你可能需要重启系统才能使用某些已安装的应用。类似地，你可以方便地安装列表中的任何程序。

提示一下，还有一个由不同的开发人员编写的类似脚本，名为 post_install.sh。它与 Alfred 完全相同，但提供了一些不同的应用。请查看以下链接获取更多详细信息。

这两个脚本能让懒惰的用户，特别是新手，只需点击几下鼠标就能够轻松快速地安装他们想要在 Ubuntu Linux 中使用的大多数常见应用、工具、更新、小程序，而无需依赖官方或者非官方文档的帮助。

就是这些了。希望这篇文章有用。还有更多好东西。敬请期待！

干杯！

via: https://www.ostechnix.com/an-automated-way-to-install-essential-applications-on-ubuntu/

作者： SK 选题： lujun9972 译者： geekpi 校对： wxy

如何在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 module: "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
作为配置文件，而在production环境中我们系统它支持提供外部的配置文件 application-production.yml
。
./gradlew bootRun # 开发环境下默认使用项目里的application.yml
# 在本地测试使用外部配置文件
./gradlew bootRun -Dspring.config.location=/path/to/application-production.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-production.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-production.yml root@your_server_ip:/root/spring-blog/current
然后 SSH
登录服务器，修改配置文件 application-production.yml
，试运行应用。
ssh root@your_server_ip
cd spring-blog/current
java -jar SpringBlog-0.1.jar --spring.config.location=application-production.yml
# application-production.yml
server:
address: raysmond.com # 使用域名或者IP，启动之后就可以这个域名或IP访问网站了
port: 80
contextPath:
spring:
profiles:
active: production
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-production.yml \
> ../logs/production.log 2> ../logs/production.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/production.log
ERROR_LOG=$HOME/logs/production.err
CONFIG=$HOME/application-production.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-production.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-production.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
一键部署到远程服务器了。 参考技术A Spring 框架作为目前非常流行的一个 Java 应用开发框架，它所包含的内容是非常繁多的。Spring 框架包含几十个不同的子项目，涵盖应用开发的不同方面。要在这些子项目之间进行选择，并快速搭建一个可以运行的应用是比较困难的事情。