linux下搭建各种应用
1，云服务器搭建
（1）新购买的云服务器，装centos7的系统。这里置为停止状态
（2）选择重装系统
（3）点击确定
（4）装好以后会自动启动。我们先用xshell连接服务器
2，安装docker
docker安装
（1）
sudo yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-engine
（2）
sudo yum install -y yum-utils
（3）
sudo yum-config-manager \
--add-repo \
https://download.docker.com/linux/centos/docker-ce.repo
（4）
sudo yum-config-manager --enable docker-ce-nightly
（5）
sudo yum-config-manager --enable docker-ce-test
（6）
sudo yum-config-manager --disable docker-ce-nightly
（7）
sudo yum install docker-ce docker-ce-cli containerd.io
全部选y
如果下载速度太慢
ctrl+c取消下载。执行下面三行代码
1、yum install -y yum-utils
2、yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
3、yum install docker-ce
如果执行上面三行代码没用。
则参考离线安装docker-ce
docker离线安装
（8）
yum list docker-ce --showduplicates | sort -r
（9）
sudo systemctl start docker
出现这个docker环境就算搭好了
3，查看防火墙，关闭
4 , jdk1.8
下载jdk 1.8 linux版本
放在这个目录下
解压tar包
tar -zxvf jdk-8u11-linux-x64.tar.gz
配置环境变量
不用配置classpath。导入时候只导入java_home 跟jre_home 和path
出现这个版本代表环境安装成功
5，tomcat
（1）
docker pull tomcat
#docker 下载镜像速度过慢，配置阿里镜像
将大括号的镜像加速器路径复制
回到xshell
配置好以后，拉取速度相当快。
（2）创建tomcat容器
docker run -d -p8080:8080 --name tomcat tomcat
（3）这时候访问可能会404
（4）
6，mysql
（1）
docker search mysql5.7
（2）
docker pull acdaic4v/mysql5.7-k2
（3）
docker run -itd --name mysql -p3309:3306 -e MYSQL_ROOT_PASSWORD=ljs acdaic4v/mysql5.7-k2
（4）
（5）成功
7，redis
（1）
docker pull redis
（2）
docker run -d -p:6378:6379 --name redis redis
（3）因为redis常用所以安装在云服务器下
现用redisdesktopManager可视化工具连接
redis可视化工具下载
8，虚拟机安装
多个大型应用，普通的服务器负载不了。我们需要把应用安装在虚拟机中
（1）下载安装VM，下一步下一步就行了
（2）
（3）
（4）选择centos7的镜像安装
（5）没有镜像的下载个centos7 的镜像
https://www.cnblogs.com/caidingyu/p/10679422.html
（6）点击下一步
这里新建一个比root权限小的用户名。
（7）
（8）
（9）不要点击完成
（10）虚拟机内存必须3g以上
（11）等待安装完毕
网路选择桥接模式
（12）普通用户切换root
su root
输入密码
z123456
（13）将之前云服务器上的应用全部安装过来
9,可视化工具portainer安装
（1）
docker volume create portainer_data
（2）
docker run -d -p 9010:9000 -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer
（3）设置密码
（4）可以使用可视化工具，进行批量删除容器，批量启动，批量杀死容器
10，消息中间件
10.1 activemq
（1）
docker search activemq
（2）
docker pull webcenter/activemq
（3）
docker run -d --name activemq -p 61616:61616 -p 8161:8161 webcenter/activemq
（4）
####activemq代码实例
（1）springboot项目创建
（2）引入pom.xml依赖
<!--activemq-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-activemq</artifactId>
</dependency>
<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-pool</artifactId>
</dependency>
（3）
application.yaml
spring:
activemq:
broker-url: tcp://xxxxx:61616
user: admin
password: admin
close-timeout: 15s
packages:
trust-all: true
broker-url 配置服务器名加61616端口号
（4）配置类
package com.testactivemq.activemq.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.config.DefaultJmsListenerContainerFactory;
import org.springframework.jms.config.JmsListenerContainerFactory;
import javax.jms.ConnectionFactory;
@Configuration
public class ActiveMqConfig {
//队列模式工厂名称
public final static String JMS_LISTENER_CONTAIN_FACTORY_QUEQUE="jmsListennerContainerFactoryQueque";
//发布订阅模式的工厂名称
public final static String JMS_LISTENER_CONTAIN_FACTORY_TOPIC="jmsListennerContainerFactoryTopic";
//管道名称 队列模式的管道名称
public final static String JMS_QUEQUE="jmsqueque";
//管道名称2 发布订阅模式的管道名称
public final static String JMS_TOPIC="jmstopic";
//创建两个jmsListenerContainerFactory对象
//其中一种点对点模式的工厂，专门生产点对点模式的管道
@Bean(ActiveMqConfig.JMS_LISTENER_CONTAIN_FACTORY_QUEQUE)
public JmsListenerContainerFactory<?> jmsListenerContainerFactoryQueque(ConnectionFactory activeMqConnectionFactory){
DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
factory.setPubSubDomain(false);
factory.setConnectionFactory(activeMqConnectionFactory);
return factory;
}
//另外一个是发布订阅模式的工厂，，专门发布订阅模式的管道
@Bean(ActiveMqConfig.JMS_LISTENER_CONTAIN_FACTORY_TOPIC)
public JmsListenerContainerFactory<?> jmsListenerContainerFactoryTopic(ConnectionFactory activeMqConnectionFactory){
DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
factory.setPubSubDomain(true);
factory.setConnectionFactory(activeMqConnectionFactory);
return factory;
}
}
点对点模式
（1）provider
package com.testactivemq.activemq.producer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import javax.jms.Destination;
@Service
public class ActivemqQuequeProducer {
private static Logger logger= LoggerFactory.getLogger(ActivemqQuequeProducer.class);
@Resource
private JmsTemplate jmsTemplate;
public void sendQueMessage(Destination destination,String message){
logger.info("生产者生产了一条消息"+message);
this.jmsTemplate.convertAndSend(destination,message);
}
}
（2）consumer
package com.testactivemq.activemq.consummer;
import com.testactivemq.activemq.config.ActiveMqConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Service;
@Service
public class ActiveMqQuequeConsumer {
private static Logger logger= LoggerFactory.getLogger(ActiveMqQuequeConsumer.class);
@JmsListener(destination = ActiveMqConfig.JMS_QUEQUE,containerFactory = ActiveMqConfig.JMS_LISTENER_CONTAIN_FACTORY_QUEQUE)
public void onQuequeMessage(String message){
logger.info("A接受到了来自于jms_queque的管道信息，执行A任务"+message);
}
@JmsListener(destination = ActiveMqConfig.JMS_QUEQUE,containerFactory = ActiveMqConfig.JMS_LISTENER_CONTAIN_FACTORY_QUEQUE)
public void onQuequeMessage2(String message){
logger.info("B接受到了来自于jms_queque的管道信息，执行B任务"+message);
}
}
（3）junit
package com.testactivemq.activemq;
import com.testactivemq.activemq.config.ActiveMqConfig;
import com.testactivemq.activemq.producer.ActivemqQuequeProducer;
import org.apache.activemq.command.ActiveMQQueue;
import org.apache.activemq.command.ActiveMQTopic;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import javax.annotation.Resource;
@RunWith(SpringRunner.class)
@SpringBootTest
public class ActivemqApplicationTests {
@Resource
ActivemqQuequeProducer activemqQuequeProducer;
@Test
public void contextLoads() {
for (int i=0;i<100;i++){
activemqQuequeProducer.sendQueMessage(new ActiveMQQueue(ActiveMqConfig.JMS_QUEQUE),"我是消息："+i);
}
}
发布订阅模式
（1）provider
public void sendTopicMessage(Destination destination,String message){
logger.info("生产者生产了一条消息"+message);
this.jmsTemplate.convertAndSend(destination,message);
};
（2）consumer
package com.testactivemq.activemq.consummer;
import com.testactivemq.activemq.config.ActiveMqConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Service;
@Service
public class ActiveMqTopicConsumer {
private static Logger logger= LoggerFactory.getLogger(ActiveMqTopicConsumer.class);
@JmsListener(destination = ActiveMqConfig.JMS_TOPIC,containerFactory = ActiveMqConfig.JMS_LISTENER_CONTAIN_FACTORY_TOPIC)
public void onQuequeMessage(String message){
logger.info("A接受到了来自于jms_topic的管道信息，执行A任务"+message);
}
@JmsListener(destination = ActiveMqConfig.JMS_TOPIC,containerFactory = ActiveMqConfig.JMS_LISTENER_CONTAIN_FACTORY_TOPIC)
public void onQuequeMessage2(String message){
logger.info("B接受到了来自于jms_topic的管道信息，执行B任务"+message);
}
}
（3）junit
@Test
public void contextLoads2() {
for (int i=0;i<100;i++){
activemqQuequeProducer.sendTopicMessage(new ActiveMQTopic(ActiveMqConfig.JMS_TOPIC),"我是消息："+i);
}
}
###点对点模式基于queue是一个生产者对应一个消费者。。而发布订阅模式基于topic，一个生产者对应多个消费者。
10.2 rabbitmq
（1）
docker pull rabbitmq:management
（2）
docker run -d -p 5672:5672 -p 15672:15672 --name rabbitmq rabbitmq:management
（3）
代码实例
（1）创建一个springboot项目
（2）
<!--rabbitmq-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
（3）application.properties
server.port=8080
spring.rabbitmq.host=xxxxxxx
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.publisher-confirms=true
（4）队列配置类
package com.testrabbitmq.rabbitmq.config;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RabbitConfig {
@Bean
public Queue helloQueue(){
return new Queue("hello");
}
}
（5）sender
package com.testrabbitmq.rabbitmq.provider;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Date;
@Component
public class Sender {
@Autowired
private AmqpTemplate amqpTemplate;
public void send(){
String context="hello"+new Date();
System.out.println("sender:"+context);
this.amqpTemplate.convertAndSend("hello",context);
}
}
（6）receiver
package com.testrabbitmq.rabbitmq.consumer;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
@RabbitListener(queues = "hello")
public class Receiver {
@RabbitHandler
public void receive(String hello){
System.out.println("receiver:"+hello);
}
}
（7）junit
package com.testrabbitmq.rabbitmq;
import com.testrabbitmq.rabbitmq.provider.Sender;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@SpringBootTest
public class RabbitmqApplicationTests {
@Autowired
private Sender sender;
@Test
public void contextLoads() {
sender.send();
}
}
10.3 rocketmq
（1）rocketmq要启动两个服务
docker run -d -p 9876:9876 -v `pwd`/data/namesrv/logs:/root/logs -v `pwd`/data/namesrv/store:/root/store --name rmqnamesrv -e "MAX_POSSIBLE_HEAP=100000000" rocketmqinc/rocketmq:4.4.0 sh mqnamesrv
docker run -d -p 10911:10911 -p 10909:10909 -v `pwd`/data/broker/logs:/root/logs -v `pwd`/data/broker/store:/root/store --name rmqbroker --link rmqnamesrv:namesrv -e "NAMESRV_ADDR=namesrv:9876" -e "MAX_POSSIBLE_HEAP=200000000" rocketmqinc/rocketmq:4.4.0 sh mqbroker
（2）安装rocketmq控制台
docker search rocketmq-console
docker pull styletang/rocketmq-console-ng
docker run -e "JAVA_OPTS=-Drocketmq.namesrv.addr=127.0.0.1:9876 -Dcom.rocketmq.sendMessageWithVIPChannel=false" -p 8081:8080 -t styletang/rocketmq-console-ng
会报错。不理它先。重新启动xshell
（3）
docker exec -it rmqnamesrv bash
cat /etc/hosts
（4）
（5）使用vi命令报错
vi命令
要将上面的172.17.0.9改成现在你自己的服务器
（6）改完以后是stop服务再start服务。而不是restart
搭建成功
11，nexus私服
（1）
docker search nexus
（2）
docker pull sonatype/nexus3
（3）
docker run -d -p8082:8081 --name nexus sonatype/nexus3
（4）访问私服
12,elk+kafka
（1）首先下载4个服务的镜像。分别启动
docker pull elasticsearch
docker run -d -p9200:9200 --name elasticsearch elasticsearch
docker pull kibana
docker run -d -it --name kibana -p5601:5601 --link elasticsearch:elasticsearch kibana
docker pull spotify/kafka
docker run -d -p9092:9092 --name kafka spotify/kafka
docker pull logstash
#重点
docker run -d -it --name logstash --link elasticsearch:elasticsearch --link kafka:kafka logstash
到此为止4个容器启动成功
#####代码实例，容器的使用方法
（1）zookeeper整合kafka
下载zookeeper
docker pull zookeeper
docker run -d -p2181:2181 --name zookeeper zookeeper
停止之前的kafka，使用以上命令
docker run --name kafka \
-p 9092:9092 \
-e KAFKA_BROKER_ID=0 \
-e KAFKA_ZOOKEEPER_CONNECT=192.168.1.106:2181 \
-e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://192.168.1.106:9092 \
-e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 \
-d spotify/kafka
zookeeper和kafka启动成功
1，进入kafka容器
docker exec -it kafka /bin/bash
2，创建my_log打印主题
/opt/kafka/bin/kafka-topics.sh --create --zookeeper xxxx:2181 --replication-factor 1 --partitions 1 --topic my_log
但是执行这段后，报错
直接进这个目录下查找原来是这样
所以稍加修改变成了这样
/opt/kafka_2.11-0.10.1.0/bin/kafka-topics.sh --create --zookeeper xxxx:2181 --replication-factor 1 --partitions 1 --topic my_log
但是启动后还是有错，继续找出错原因
出现这种错误的 原因可能是zookeeper和kafka的配置文件中端口号配置不一
致
3，修改kafka和zookeeper的配置文件
修改service.properties和zookeeper.properties
vi zookeeper.properties
保存后，stop容器，再start容器
4，再进入容器。执行第二步的那段代码
/opt/kafka_2.11-0.10.1.0/bin/kafka-topics.sh --create --zookeeper xxxx:2181 --replication-factor 1 --partitions 1 --topic my_log
看到my_log就算成功了
5，查询创建主题
/opt/kafka_2.11-0.10.1.0/bin/kafka-topics.sh --list --zookeeper xxxxx:2181
6，查询成功。
13，nginx
13.1，搭建nginx
docker pull nginx
docker run --name nginx-test -p 80:80 -d nginx
13.2，nginx配置映射
1，将nginx关键目录映射到本机
mkdir -p /root/nginx/www /root/nginx/logs /root/nginx/conf
2，将nginx-test容器配置文件copy到本地
docker ps -a
docker cp a2aa730207ba:/etc/nginx/nginx.conf /root/nginx/conf
3，创建新的nginx容器
先停止之前的nginx-test
docker stop a2aa730207ba
docker run -d -p 80:80 --name nginx-web -v /root/nginx/www:/usr/share/nginx/html -v /root/nginx/conf/nginx.conf:/etc/nginx/nginx.conf -v /root/nginx/logs:/var/log/nginx nginx
4，在window下创建一个html，放到linux的root/nginx/www下
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>docker搭建nginx</title>
</head>
<body>
<h1>docker搭建nginx映射成功</h1>
<p>666666666</p>
</body>
</html>
13.3，nginx设置反向代理
vim
如下图设置，上图那个只是截图。。。。
配置server
#这样就可以用本机80端口代理本机8080端口了
试一下
将一个jar包打包放到服务器下。默认8080端口
然后用nginx的80端口去访问
13.4，nginx设置静态资源服务器
13.4.1， 简单启动nginx
docker run -d -p 80:80 nginx
13.4.2，创建本地挂载，并删除一些挂载
mkdir -p /opt/nginx/{conf,conf.d,html,logs}
rm -rf /opt/nginx/{conf.d,html,log}
13.4.3，将docker下的nginx.conf拉到本地
docker cp 容器id:/etc/nginx/nginx.conf /opt/nginx/conf/
13.4.4，通过xftp找到nginx.conf
右键记事本编辑
server {
listen 80;
server_name localhost;
location / {
root /usr/share/nginx/html;
index index.html index.htm;
}
}
13.4.5，运行镜像
docker run \
--name nginx8088 \
-d -p 8088:80 \
-v /opt/nginx/log:/var/log/nginx \
-v /opt/nginx/html:/usr/share/nginx/html \
-v /opt/nginx/conf/nginx.conf:/etc/nginx/nginx.conf \
-v /opt/nginx/conf.d:/etc/nginx/conf.d \
nginx
13.4.6，在/opt/nginx/html 目录下存放图片资源
13.4.7，访问路径是
http://服务器名:8088/图片名
14，zipkin可视化工具
springcloud项目中，需要打印日志
可以在消费者，生产者下的pom.xml引入sleuth链路追踪依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-sleuth</artifactId>
<version>2.1.7.RELEASE</version>
</dependency>
可以在消费者application.yaml下配置
logging:
level:
root: info
这样。会打印日志。但是不太直观所以有了zipkin可视化工具
14.1，zipkin的安装和使用
1,pom.xml
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-sleuth</artifactId>
<version>2.1.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-zipkin</artifactId>
</dependency>
2，application.yaml
spring:
application:
name: user-consumer
sleuth:
sampler:
probability: 1
zipkin:
base-url: http://xxxx:9411
discoveryClientEnabled: false
这个是放在我的虚拟机上的。。。先启动docker容器。
现在启动springcloud微服务项目
1，启动eureka注册中心
2，启动服务提供者
3，启动服务消费者
4，访问zipkin
可以通过调用consumer接口来访问
然后查看zipkin
可以点开里面查看接口详细调用所耗费的时间等情况
15，docker版本的jenkins使用
15.1，jenkins安装
docker pull jenkins/jenkins
一般jenkins要配置挂载
详情见这篇
挂载jenkins
将密码粘贴，进入，选择第一个
耐心等待安装完毕
选择jdk1.8，去甲骨文那安装。。。填写自己的账户名和密码
#git这里直接取个别名。然后自动安装
gradle这里也是一样
maven也一样
15.2，jenkins准备工作
提前准备一个GitHub，保存的springboot代码。。。
详情见
1，虚拟机下安装maven
直接下载linux版本的。。。用xftp拉进去
可以参考这篇文章
linux下安装maven
配置文件
JAVA_HOME=usr/java/jdk1.8.0_11
JRE_HOME=$JAVA_HOME/jre
PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin
export JAVA_HOME JRE_HOME MAVEN_HOME PATH
export MAVEN_HOME=usr/local/software/apache-maven-3.6.3
export PATH=$MAVEN_HOME/bin:$PATH
source /etc/profile
2，虚拟机下安装git
在github下下载最新源码安装
github源码构建git
3，git构建公钥
详情参考
git公钥配置
查看公钥
cat ~/.ssh/id_rsa.pub
复制到github上
可以直接连接了
扫一扫
973
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
