[系统运维]Docker+fastDFS+SpringBoot实现图片上传

Docker+fastDFS+SpringBoot实现图片上传(一)

使用技术栈：

SpringBoot-version: 2.5.2
Linux:centos7
Docker-version: 20.10.7
FastDFS-version: ygqygq2/fastdfs-nginx(整合nginx的版本)

安装Docker:

使用yum源安装

yum -y install docker

安装好后启动docker

systemctl start docker

安装好后可通过：systemctl status docker 查看Docker容器状态

简单介绍一下docker常用命令(介绍些我认识的 哈哈)

docker pull  imageName //从docker Hub中拉取镜像
docker search  imageName   //在 Docker Hub 中搜索镜像
docker ps containerNamecontainerID //查看在运行的容器
docker ps -a containerName/containerID //查看待运行的容器
docker rm containerName/containerID //删除 docker ps 的容器
docker rmi imagesName/imageID //根据镜像名或镜像ID删除镜像
docker stop containerName/containerID //根据容器名或容器ID暂停容器
docker run  imagesName/imageID//启动镜像

注意： 在docker rm 容器名ID 前，需要暂停该容器 docker stop 容器名/容器ID

介绍一下linux中的防火墙

systemctl status firewalld		 			#查看firewall防火墙状态
firewall-cmd --list-ports					#查看firewall防火墙开放端口
systemctl start firewalld.service			#打开firewall防火墙
systemctl stop firewalld.service			#关闭firewall防火墙
firewall -cmd --reload						#重启firewal防火墙
systemctl disable firewalld.service			#禁止firewall开机启动  

#开放firewall防火墙端口，需重启防火墙生效
firewall-cmd --zone=public --add-port=80/tcp --permanent 	

命令含义:
–zone #作用域
–add-port=80/tcp #添加端口，格式为：端口/通讯协议
–permanent #永久生效，没有此参数重启后失效

iptable防火墙：

service iptables status 	#查看iptable防火墙状态
iptables -L -n -v			#查看iptable防火墙规则
systemctl start iptables	#打开iptable防火墙
service iptables stop	    #关闭iptable防火墙
yum install  iptables -y	#安装iptable防火墙
systemctl enable iptables	#开机自启iptable防火墙
systemctl disable firewalld	#开机自动关闭iptable防火墙
iptables -F					#清空iptable的规则
service iptables save  		#保存iptable防火墙规则

iptables -A INPUT -p tcp --dport 80 -j REJECT #禁止来自80端口访问的数据包
iptables -A INPUT -p tcp --dport 80 -j ACCEPT #允许来自80端口访问的数据包

iptables -A OUTPUT -p tcp --sport 80 -j REJECT #禁止从80端口出去的数据包
iptables -A OUTPUT -p tcp --sport 80 -j ACCEPT #允许从80端口出去的数据包

介绍目的： 需要将启动的容器的端口开放 否则会被防火墙拦截

在docker中安装FastDFS

搭建DFS有两种方式，一种是在服务器上下载fastDFS的压缩包来安装，再进行一系列的配置(确实比较繁琐)；另一种是在服务器上直接起docker服务，docker镜像已经将大部分的配置搞定了，其余的就是一些简单必要的配置，如容器之间的通信等。 这里我们直接使用docker pull 拉取镜像
先搜索此镜像：

docker search fastDFS //搜索

图片:

选择整合了nginx的版本，然后拉取此镜像

docker pull ygqygq2/fastdfs-nginx

拉取完成后，查看是否拉取成功

docker images

然后我们进行以下操作

docker network create fastdfs-net 
docker run -dit --network=fastdfs-net --name tracker -v /var/fdfs/tracker:/var/fdfs ygqygq2/fastdfs-nginx:latest tracker
docker run -dit --network=fastdfs-net --name storage0 -e TRACKER_SERVER=tracker:22122 -v /var/fdfs/storage0:/var/fdfs ygqygq2/fastdfs-nginx:latest storage

第一段：创建一个名字为fastdfs-net的docker局域网络
第二段：启动tracker服务
第三段：启动storage服务
注意：将–network=fastdfs-net 改成–network=host(即保持容器的网络和宿主机的网络是一致的)
将-e TRACKER_SERVER=tracker:22122 中的tracker改成自己的宿主机ip；
docker -dit：
-d：–detach：在后台运行容器，并且打印容器id
-i：–interactive：即使没有连接，也要保持标准输入保持打开状态，一般与 -t 连用
-t：–tty：分配一个伪tty，一般与 -i 连用
总的来说就是：在后台启动此容器，以标准输入的方式给容器产生一个交互性shell命令行
–name storage1：给次容器起个别名为storage1

-e TRACKER_SERVER=tracker:22122：设置一个名为TRACKER_SERVER的环境变量为，并绑定内容为tracker:22122；

-v /var/fdfs/storage1:/var/fdfs：这是宿主机与docker之间挂载的共享目录卷

ygqygq2/fastdfs-nginx:latest：镜像的名字和tag；(表示是最新版本的镜像)

最后一个storage表示此容器为 storage类型；
Tracker server
Tracker是FastDFS的协调者，负责管理所有的storage server和group，每个storage在启动后会连接Tracker，告知自己所属的group等信息，并保持周期性的心跳，tracker根据storage的心跳信息，建立group==>[storage server list]的映射表；

Storage server
Storage server以组（卷，group或volume）为单位组织，一个group内包含多台storage机器，数据互为备份，存储空间以group内容量最小的storage为准，所以建议group内的多个storage尽量配置相同，以免造成存储空间的浪费；

启动镜像：
启动命令更改过以后，先启动tracker的服务镜像，再启动storage服务镜像(如果只是测试，可以启动一个)；
启动后可以看到是两个容器已经起来了：

到这里我们的linux+docker+fastdfs就已经安装成功了。

fastDFS搭建完成之后该是编写java代码：
pom文件

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.github.tobato</groupId>
            <artifactId>fastdfs-client</artifactId>
            <version>1.27.2</version>
        </dependency>
        <dependency>
            <groupId>net.oschina.zcx7878</groupId>
            <artifactId>fastdfs-client-java</artifactId>
            <version>1.27.0.0</version>
        </dependency>

application.yml

server:
  port: 8081
fastdfs:
  nginx:
    host: http://192.168.2.2:8080/

创建fastdfs-client.properties

## fastdfs-client.properties

fastdfs.connect_timeout_in_seconds = 5
fastdfs.network_timeout_in_seconds = 30

fastdfs.charset = UTF-8

fastdfs.http_anti_steal_token = false
fastdfs.http_secret_key = FastDFS1234567890
fastdfs.http_tracker_http_port = 80

fastdfs.tracker_servers = 192.168.2.2:22122

## Whether to open the connection pool, if not, create a new connection every time
fastdfs.connection_pool.enabled = true

## max_count_per_entry: max connection count per host:port , 0 is not limit
fastdfs.connection_pool.max_count_per_entry = 500

## connections whose the idle time exceeds this time will be closed, unit: second, default value is 3600
fastdfs.connection_pool.max_idle_time = 3600

## Maximum waiting time when the maximum number of connections is reached, unit: millisecond, default value is 1000
fastdfs.connection_pool.max_wait_time_in_ms = 1000

package com.example.springbootfastdfs.config;

import com.github.tobato.fastdfs.FdfsClientConfig;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableMBeanExport;
import org.springframework.context.annotation.Import;
import org.springframework.jmx.support.RegistrationPolicy;

@Configuration
@Import(FdfsClientConfig.class)
@EnableMBeanExport(registration = RegistrationPolicy.IGNORE_EXISTING)
public class ComponetImport {
    // 导入依赖组件
}

fastDFS工具类

package com.example.springbootfastdfs.util;

import org.csource.common.MyException;
import org.csource.fastdfs.ClientGlobal;
import org.csource.fastdfs.StorageClient1;
import org.csource.fastdfs.TrackerClient;
import org.csource.fastdfs.TrackerServer;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;

public class FastDFSUtils {
    private static StorageClient1 client1;

    static {
        try {
            ClientGlobal.initByProperties("fastdfs-client.properties");
            TrackerClient trackerClient = new TrackerClient();
            TrackerServer trackerServer = trackerClient.getConnection();
            client1 = new StorageClient1(trackerServer, null);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (MyException e) {
            e.printStackTrace();
        }
    }

    public static String upload(MultipartFile file) {
        String oldName = file.getOriginalFilename();
        try {
            return client1.upload_file1(file.getBytes(), oldName.substring(oldName.lastIndexOf(".") + 1), null);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (MyException e) {
            e.printStackTrace();
        }
        return null;
    }

}

文件上传

package com.example.springbootfastdfs.controller;

import com.example.springbootfastdfs.util.FastDFSUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;

@RestController
@RequestMapping("/file")
public class FileUploadController {
    @Value("${fastdfs.nginx.host}")
    String nginxHost;

    /**
     * 上传
     * @param file
     * @return
     * @throws IOException
     */
    @RequestMapping("/upload")
    public String uploadFile(MultipartFile file) throws IOException {
        String upload = FastDFSUtils.upload(file);
        String url = nginxHost + upload;
        return url;
    }
}

解决跨域问题

package com.example.springbootfastdfs.cosr;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;

@Configuration
public class CorsConfig {
    public CorsConfig() {
    }

    @Bean
    public CorsFilter corsFilter() {
        CorsConfiguration config = new CorsConfiguration();
        config.addAllowedOriginPattern("*");
        config.setAllowCredentials(true);
        config.addAllowedHeader("*");
        config.addAllowedMethod("*");
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", config);
        return new CorsFilter(source);
    }
}

通过postMan测试

如果没有安装PostMan可以安装一下。

结束语

首先声明该博客借鉴于https://blog.csdn.net/magic_guo/article/details/119189739
本人小白，大多是根据此博客学习如有不对的地方，希望多多指点