精华内容
下载资源
问答
  • python杂草 它是什么? 适用于seaweedfs( )的python模块(旧名称是:weed-fs( ))。 Python版本 python3.7 + 注意:对于旧的python2.7版本,请使用v0.2.3-suited-for-python2.7的分支: v0.2.3-suited-for-...
  • weedfs安装使用

    2020-12-24 09:48:37
    weedfs 参考: seaweedfs官网 分布式小文件系统fastdfs与weedfs的对比 初窥weedfs分布式文件系统 看:Seaweedfs的安装和使用–研究 看:seaweedfs使用说明 看:seaweedfs文件存储服务器搭建 Seaweedfs 详细说明 ...

    weedfs

    参考:

    seaweedfs官网

    分布式小文件系统fastdfs与weedfs的对比

    初窥weedfs分布式文件系统

    看:Seaweedfs的安装和使用–研究

    看:seaweedfs使用说明

    看:seaweedfs文件存储服务器搭建

    Seaweedfs 详细说明

    filer使用:seaweedfs安装配置使用

    weed-fs使用简介

    seaweedfs 用docker快速布署及测试

    http://blog.chinaunix.net/uid-29677448-id-5602995.html

    java使用https://github.com/HalfWater/seaweedfs-java-client(自己下载编译)

    weedfs的简易安装以及使用Java编写的简单上传代码

    网上安装步骤

    1、下载weedfs:https://github.com/chrislusf/seaweedfs/releases

    wget https://github.com/chrislusf/seaweedfs/releases/download/2.14/linux_amd64.tar.gz

    mkdir -p /usr/local/weedfs/ cd /usr/localweedfs/

    mkdir -p /home/yyt/weedfs/

    /weedfs目录

    tar -xzvf linux_amd64.tar.gz

    mkdir -p /data/weedfs_data
    mkdir -p /data/weedfs_data/vol{a..c}
    mkdir -p /data/weedfs_data/master
    mkdir -p /data/weedfs_data/filter
    
    
    nohup ./weed master -mdir=/root/sea/data -port=9333 -ip="172.16.20.71" &>> /root/sea/logs/master.log &
    
    ------------------
    ./weed volume -dir="D:\data1" -max=500 -mserver="localhost:9333" -port=9331 &>>/root/sea/logs/vol1.log &
    
    ./weed volume -dir="D:\data2" -max=500 -mserver="localhost:9333" -port=9332
    &>>/root/sea/logs/vol1.log &
    
    volume默认最大7个,你可以设置100等等。。。
    -master.volumeSizeLimitMB 默认最大30000000 (30G)
    -filer.dir 目录来存储元数据,默认为指定-dir的“filer”子目录
    -master.dir用于存储元数据的数据目录,默认为与指定的-dir相同
    
    
    ./weed -log_dir='/path/to/seaweedfs/master/logs'  master  -defaultReplication="001" -mdir="./master"  -peers="1.1.2.2:9333"  -volumeSizeLimitMB=10  
    
    ./weed  -log_dir='/path/to/seaweedfs/volume/logs'  volume -dir="volume" -ip="1.1.2.3" -max="3" -mserver='1.1.2.2:9333'  -rack='rack2' 
    

    建议在启动服务时都指定一下log_dir, 否则使用的默认值是/tmp目录, 生成的文件较多, 很难看.

    docker环境搭建

    https://blog.csdn.net/weixin_34380296/article/details/92359656

    ps -ef | grep weed
    
    docker rm -f master ; docker rm -f volume
    
    #docker ps -n 4
    
    cd /home/yyt/weedfs/data ;du -sh *
    
    # 创建文件夹
    rm -rf /home/yyt/weedfs/data && \
    mkdir -p /home/yyt/weedfs/data/master && \
    mkdir -p /home/yyt/weedfs/data/vol1
    
    #用这条命令,开启一个master
    docker run -d --restart=always \
    -p 9333:9333 \
    --name master \
    -v /home/yyt/weedfs/data/master:/data \
    chrislusf/seaweedfs \
    master \
    -ip="10.60.0.22"
    
    #用这条命令,开一个volume,master不用写成ip
    docker run -d --restart=always \
    -v /home/yyt/weedfs/data/vol1:/data \
    -p 8089:8080 -p 18080:18080 \
    --name volume \
    --link master \
    chrislusf/seaweedfs \
    volume \
    -max=15 -mserver="master:9333" -port=8080 \
    -publicUrl="10.60.0.22:8089"
    
    
    docker run -d --restart=always \
    -p 8089:8089 -p 18080:18080 \
    --name volume1 \
    --link master \
    chrislusf/seaweedfs \
    volume \
    -max=15 -mserver="10.60.0.23:9333" -port=8089
    
    # 可以创建第二个volume
    docker run -d --restart=always \
    -p 8090:8090 -p 18080:18080 \
    --name volume2 \
    chrislusf/seaweedfs \
    volume -volumeSizeLimitMB=10 -mserver="master:9333" -port=8090 
    
    # 访问
    http://10.60.0.23:9333/
    

    docker-compose方式搭建

    docker-compose搭建:
    debian8 
    python2.7 
    docker17.04 
    docker-compose1.12.0
    
    1)git clone https://github.com/chrislusf/seaweedfs.git
    2)cd seaweedfs/docker
    3)docker build -t sunsl/seaweedfs .
    4)修改docker-compose.yml中的 image 为 sunsl/seaweedfs
    5)docker-compose up
    

    参考docker-compose.yml

    version: '2'
    
    services:
      master:
        image: chrislusf/seaweedfs # use a remote image
        volumes:
          - $PWD/out:/etc/seaweedfs/out
          - $PWD/security.toml:/etc/seaweedfs/security.toml
          - $PWD/filer.toml:/etc/seaweedfs/filer.toml
          - /var/yr/seaweedfs_data/master:/data
        # ports:
        #   - 9333:9333
        #   - 19333:19333
        command: "master"
        restart: always
        networks:
          seaweedfs_network:
    
      volume:
        image: chrislusf/seaweedfs # use a remote image
        volumes:
          - $PWD/out:/etc/seaweedfs/out
          - $PWD/security.toml:/etc/seaweedfs/security.toml
          - $PWD/filer.toml:/etc/seaweedfs/filer.toml
          - /var/yr/seaweedfs_data/node1:/data
        # ports:
        #   - 8080:8080
        #   - 18080:18080
        command: 'volume -max=45 -index=leveldb -mserver="master:9333" -port=8080'
        depends_on:
          - master
        restart: always
        networks:
          seaweedfs_network:
    
      filer:
        image: chrislusf/seaweedfs # use a remote image
        volumes:
          - $PWD/out:/etc/seaweedfs/out
          - $PWD/security.toml:/etc/seaweedfs/security.toml
          - $PWD/filer.toml:/etc/seaweedfs/filer.toml
          - /var/yr/seaweedfs_data/filerdb:/data/filerdb
    #    ports:
    #      - 8880:8888
    #      - 18880:18888
        command: 'filer -master="master:9333" -collection "finance"'
        # tty: true
        # stdin_open: true
        depends_on:
          - master
          - volume
          - mysql
        restart: always
        networks:
          seaweedfs_network:
    
      nxinx:
        image: nginx:alpine
        volumes:
          - $PWD/pwd:/pwd
          - $PWD/nginx.conf:/etc/nginx/nginx.conf
        links:
          - filer
        ports:
          - 8600:80
        restart: always
        networks:
          seaweedfs_network:
    
      mysql:
        image: mysql:latest
        environment:
          - MYSQL_ROOT_PASSWORD=lambdax
          - MYSQL_USER=finance
          - MYSQL_PASSWORD=shuzhi2019
          - MYSQL_DATABASE=seaweedfs_finance_filer
        volumes:
          - /var/yr/seaweedfs_data/mysql_data:/var/lib/mysql
        ports:
          - "8599:3306"
        restart: always
        networks:
          seaweedfs_network:
    
      # cronjob:
      #   image: chrislusf/seaweedfs # use a remote image
      #   volumes:
      #     - ./out:/etc/seaweedfs/out
      #     - ./security.toml:/etc/seaweedfs/security.toml
      #     - ./filer.toml:/etc/seaweedfs/filer.toml
      #   # ports:
      #   command: 'cronjob'
      #   environment:
      #     # Run re-replication every 2 minutes
      #     CRON_SCHEDULE: '*/2 * * * * *' # Default: '*/5 * * * * *'
      #     WEED_MASTER: master:9333 # Default: localhost:9333
      #   depends_on:
      #   - master
      #   - volume
        # restart: always
        # networks:
        #   seaweedfs_network:
    
    
    networks:
       seaweedfs_network:
          ipam:
             config:
             - subnet: 192.168.10.0/24
               gateway: 192.168.10.111
    
    
    

    API使用

    1)获取Fid和URL
    # curl "http://localhost:9333/dir/assign?replication=001"
    curl -X POST http://localhost:9333/dir/assign
    {"fid":"1,0240cd0175","url":"172.18.0.3:8080","publicUrl":"172.18.0.3:8080","count":1}
    
    #申请带存活时间的fid 
    # ttl string 存活时间 1m,1h,1d,1M,1y
    # 获取fid带ttl的 http://localhost:9333/dir/assign?ttl=2m
    # 获取上传带ttl的 http://localhost:9333/5,01d8f2bc3c?ttl=2m
    # 取fid带ttl的时间要大于等于上传带ttl的时间
    
    # 上传
    curl -F file=@qs.png http://192.168.2.101:9333/5,01d8f2bc3c
    
    # 查看
    GET http://192.168.2.101:9333/5,01d8f2bc3c
    
    # 查看卷
    # curl -X get http://192.168.0.193:9333/dir/lookup?volumeId=8
    GET http://localhost:9333/dir/lookup?volumeId=40
    {
        "volumeId": "40",
        "locations": [
            {
                "url": "192.168.10.212:8082",
                "publicUrl": "192.168.10.212:8082"
            }
        ]
    }
    
    # 查看卷信息
    http://localhost:8081/status?pretty=y
    http://localhost:8082/status?pretty=y
    
    # 压缩空间
    http://localhost:9333/vol/vacuum
    

    监控

    (1)tcp端口监控
    
    (2)测试写入, 每1分钟写入1次
    [{"fileName":"/tmp/anaconda-post.log","error":"Post http://172.17.0.7:9333/dir/assign: dial tcp 172.17.0.7:9333: connection refused"}]  不正常的返回结果
    [{"fileName":"abc.txt","fileUrl":"172.17.0.8:8080/9,01b16f4a4c2f","fid":"9,01b16f4a4c2f","size":83}]    正常的返回结果
    
    (3)各master的 http://172.17.0.8:9333/cluster/status?pretty=y 结果, 必须要有Leader,且同一组master服务器的Leader值要相同.另外因为线上是按3个master部署的, 所以Peers中要有2个才对.   监控这一条是为了保证在出现一个master异常时, 其它master可以自动切换, 否则几个master之间的状态已经不对了, 当主master故障时就没有办法自动切换了.
    
    (4)curl "http://172.17.0.8:9333/dir/status?pretty=y"  检查DataNodes的数量, 这个值表示的是从master中查看到的DataNode的数量. 如果连续2次获取到的DataNode数量不相同, 则表明有节点down机或新扩容了节点
    

    搭建

    window环境搭建

    weed.exe master -mdir=f:\data -port=9333 -ip="localhost"
    
    weed.exe volume -dir="f:\vol" \
    -max=4 \
    -mserver="localhost:9333" -port=8083
    

    linux环境搭建

    一、安装
    1、首先安装配置golang开发环境
    go的最新版本是1.9.1 可到
    https://storage.googleapis.com/golang/go1.9.1.linux-amd64.tar.gz
    下载 go1.9.1.linux-amd64.tar.gz
    2、上传并解压到指定目录 
    sudo tar -xzf go1.9.1.linux-amd64.tar.gz -C /opt
    3、配置环境变量
    vim /etc/profile
    export GOROOT=/usr/local/go
    export PATH=$GOROOT/bin:$PATH
    #export GOPATH=$GORROT/workspace
    
    source /etc/profile
    
    #4、创建文件夹可以直接从这步开始
    mkdir -p /home/yyt/weedfs/data/ && \
    mkdir -p /home/yyt/weedfs/data/vol1 && \
    mkdir -p /home/yyt/weedfs/data/vol2 && \
    mkdir -p /home/yyt/weedfs/data/master && \
    mkdir -p /home/yyt/weedfs/data/filer
    
    rm -rf /home/yyt/weedfs/data && \
    mkdir -p /home/yyt/weedfs/data/master && \
    mkdir -p /home/yyt/weedfs/data/vol1
    
    # 查看
    netstat -lnp | grep 9333
    ps -ef | grep weed
    
    #5、启动master当前目录要使用./weed执行
    nohup /home/yyt/weedfs/weed master -mdir=/home/yyt/weedfs/data/master -port=9333 -ip="10.60.0.22" &>>/home/yyt/weedfs/data/master/master.log &
    # 查看日志
    cat /home/yyt/weedfs/data/master/master.log
    
    #6、启动vol1
    nohup /home/yyt/weedfs/weed volume -dir="/home/yyt/weedfs/data/vol1" \
    -max=15 \
    -mserver="192.168.10.212:9333" -port=8081 \
    &>>/home/yyt/weedfs/data/vol1/vol1.log &
    
    #cat /home/yyt/weedfs/data/vol2/vol2.log
    #7、 启动vol2
    nohup /home/yyt/weedfs/weed volume -dir="/home/yyt/weedfs/data/vol2" \
    -max=15 \
    -fileSizeLimitMB=8 \
    -mserver="192.168.10.212:9333" -port=8082 \
    &>>/home/yyt/weedfs/data/vol2/vol2.log &
    
    #关闭 ps -ef | grep weedfs | grep -v grep | awk '{print $2 }' | xargs kill
    #------------------扩展
    mkdir -p /home/yyt/weedfs/data/filer/leveldb2
    #启动filer 生成一个配置文件filer.toml
    /home/yyt/weedfs/weed scaffold -config=filer -output=. 
    #修改filer.toml,把filer的数据目录的dir指向到/home/yyt/weedfs/data/filer/leveldb2下
    vi /home/yyt/weedfs/filer.toml
    #然后启动filer
    nohup /home/yyt/weedfs/weed filer -port=8888  -master=localhost:9333 &>> /home/yyt/weedfs/data/filer/filer.log &
    
    # mount挂载(一般不用,因为使用的容量是双倍的)
    mkdir -p /home/yyt/weedfs/data/newfilermount/data
    yum install -y fuse
    
    nohup /home/yyt/weedfs/weed mount -filer=localhost:8888 -dir=/home/yyt/weedfs/data/newfilermount/data &>> /home/yyt/weedfs/data/newfilermount/wefsmount.log &
    
    #filer的mount 为了方便本地操作,把一个collection里面的内容挂载导某个目录,方便操作
    #post 上传图片http://192.168.10.212:8888/path/to/sources/20150429093808_83019.jpg
    #关闭挂在需要关闭mount并且手动umont ~/wz/mdir目录,如果一般用户失败请使用root用户
    
    #使用fid上传挂载目录看不到,挂载的目录大小还是不变
    #使用/path/to/sources上传,挂载和volum大小都会增加(相当于双倍使用磁盘容量,只能用1半的容器量了),但是删除操作2个空间都会也立马释放不用在压缩了。
    #所有操作都可以访问:http://192.168.10.212:9333/
    

    总结

    启动脚本

    sh /home/yyt/weedfs/bin/start_weedfs.sh

    #!/bin/bash
    
    # master
    nohup /home/yyt/weedfs/weed master -mdir=/home/yyt/weedfs/data/master -port=9333 -ip="192.168.10.212" &>>/home/yyt/weedfs/data/master/master.log &
    
    # vol1
    nohup /home/yyt/weedfs/weed volume -dir="/home/yyt/weedfs/data/vol1" \
    -max=15 \
    -fileSizeLimitMB=8 \
    -mserver="192.168.10.212:9333" -port=8081 \
    &>>/home/yyt/weedfs/data/vol1/vol1.log &
    
    # vol2
    nohup /home/yyt/weedfs/weed volume -dir="/home/yyt/weedfs/data/vol2" \
    -max=15 \
    -fileSizeLimitMB=8 \
    -mserver="192.168.10.212:9333" -port=8082 \
    &>>/home/yyt/weedfs/data/vol2/vol2.log &
    

    sh /home/yyt/weedfs/bin/stop_weedfs.sh

    #!/bin/bash
    
    ps -ef | grep weedfs | grep -v grep | awk '{print $2 }' | xargs kill
    echo "weedfs stop"
    

    查看容量大小

    cd /home/yyt/weedfs/data ;du -sh *
    

    配置开机启动

    开机启动
    Centos 7
    vi /etc/rc.d/rc.local
    /xx.sh
    chmod +x xx.sh
    
    UBUNTU
    vi /etc/rc.local
    /weedfs/yyt/weedfs/weedfs_service.sh start
    
    启动脚本的创建
    现在我们以安装nginx为例,假设我们的nginx安装在/usr/sbin/目录下。
    - 首先,我们在/etc/init.d创建文件sudo vim nginx,并将shell代码拷贝进去。
    - 修改文件权限为755 sudo chmod 755 nginx。
    - 添加服务到启动过程 sudo update-rc.d nginx defaults。
    
    cp /weedfs/yyt/weedfs/weedfs_service.sh /etc/init.d
    
    vi /etc/init.d/weedfs_service.sh
     weedfs_service.sh添加 BEGIN INIT INFO信息
    ```yaml
    ### BEGIN INIT INFO
    # Provides:          lostphp.com
    # Required-Start:    $local_fs $network
    # Required-Stop:     $local_fs
    # Default-Start:     2 3 4 5
    # Default-Stop:      0 1 6
    # Short-Description: weedfs service
    # Description:       weedfs service daemon
    ### END INIT INFO 
    
    sudo update-rc.d start_weedfs.sh defaults
    现在,我们就可以用以下命令正常启动nginx了。
    启动
    /etc/init.d/nginx start
     停止
    /etc/init.d/nginx stop
     重启
    /etc/init.d/nginx restart
    

    eg:ubuntu设置weedfs自动启动:

    一、添加启动脚本命令

    vi /etc/rc.local
    /weedfs/yyt/weedfs/weedfs_service.sh start

    二、复制 weedfs_service.sh并之后添加 BEGIN INIT INFO信息

    cp /weedfs/yyt/weedfs/weedfs_service.sh /etc/init.d/weedfs_service.sh
    vi /etc/init.d/weedfs_service.sh
    

    修改后weedfs_service.sh如下:

    #!/bin/sh
    ### BEGIN INIT INFO
    # Provides:          lostphp.com
    # Required-Start:    $local_fs $network
    # Required-Stop:     $local_fs
    # Default-Start:     2 3 4 5
    # Default-Stop:      0 1 6
    # Short-Description: weedfs service
    # Description:       weedfs service daemon
    ### END INIT INFO 
    export master_port=9333
    export volume_port=8089
    
    ip="10.10.103.242"
    max=115
    WEEDFS_HOME=/weedfs/yyt/weedfs
    masterName=master
    volumeName=volume
    mdir="/weedfs/yyt/weedfs/data/master"
    mdir_log="/weedfs/yyt/weedfs/data/master/master.log"
    vdir="/weedfs/yyt/weedfs/data/vol1"
    vdir_log="/weedfs/yyt/weedfs/data/vol1/vol1.log"
    
    # -d 参数判断 $mdir 是否存在
    if [ ! -d "${mdir}" ]; then
      mkdir -p "$mdir"
    fi
    if [ ! -d "${vdir}" ]; then
      mkdir -p "${vdir}"
    fi
    
    # -f 参数判断 $file 是否存在
    if [ ! -f "$mdir_log" ]; then
      touch "$mdir_log"
    fi
    if [ ! -f "$vdir_log" ]; then
      touch "$vdir_log"
    fi
    
    startMaster(){
            echo "--------"Master" begin starting--------------"
            nohup ${WEEDFS_HOME}/weed master -mdir="${mdir}" -port=$master_port -ip="${ip}" &>>"${mdir_log}" &
    	
            service_pid=`lsof -i:$master_port|grep "LISTEN"|awk '{print $2}'`
            until [ -n "$service_pid" ]
                do
                  service_pid=`lsof -i:$master_port|grep "LISTEN"|awk '{print $2}'`  
                done
            echo "master pid is $service_pid"  
    
            echo "--------master start success--------------"
    }
    
    startVolume(){
            echo "---------"volume" begin starting---------------"
            nohup ${WEEDFS_HOME}/weed volume -dir="${vdir}" -max=${max} -mserver="${ip}:${master_port}" -port=$volume_port &>>"${vdir_log}" &
    
            service_pid=`lsof -i:$volume_port|grep "LISTEN"|awk '{print $2}'` 
            until [ -n "$service_pid" ]
                do
                  service_pid=`lsof -i:$volume_port|grep "LISTEN"|awk '{print $2}'`  
                done
            echo "volume pid is $service_pid"     
            echo "---------"volume" start success-----------"
    }
    
    
    stopMaster(){
            # 此处直接写port会重复所以需要加上 port= 才会只有master的进程
            P_ID=`ps -ef | grep -w port=${master_port} | grep -v "grep" | awk '{print $2}'`
            if [ "$P_ID" == "" ]; then
                echo "==="$masterName" process not exists or stop success"
            else
                kill -9 $P_ID
                echo ""$masterName" killed success"
            fi
    
    }
    
    
    stopVolume(){
    	P_ID=`ps -ef | grep -w ${volume_port} | grep -v "grep" | awk '{print $2}'`
            if [ "$P_ID" == "" ]; then
                echo "==="$volumeName" process not exists or stop success"
            else
                kill -9 $P_ID
                echo ""$volumeName" killed success"
            fi
    
    }
    
    case "$1" in
     
    start)
    	case "$2" in
    		
    		master|MASTER)
    			## 启动
    			startMaster
    			;;
    			
    		volume|VOLUME)
    			## 启动
    			startVolume
    			;;
    			
    		""|"")
    			## 启动所有
    			startMaster
    			startVolume
    			;;
        esac
    	;;
     
     stop)
    	case "$2" in
    		
    		master|MASTER)
    			stopMaster
    			;;
    			
    		volume|VOLUME)	
    			stopVolume
    			;;
    	
    		""|"")
    			stopMaster
    			stopVolume
    			
    			;;
    	esac
    	;;
     
    restart)
            $0 stop $2
            sleep 2
            $0 start $2
            echo "===restart $2 success==="
            ;;   
    esac	
    exit 0
    

    三、 赋予执行权限

    chmod +x weedfs_service.sh

    四、sudo update-rc.d start_weedfs.sh defaults

    sudo update-rc.d weedfs_service.sh defaults

    笔记

    weedfs删除比较麻烦,可使用过期删除,但是一直上传使用的情况下不会自动压缩空间(手动测试不出来,可能是上传的频率没有这么高,会自动压缩空间)。

    可以创建2对master和volume用定时器切换存储达到不服务自动瘦身的效果。

    空间占用少时不会可能不会压缩,可以手动调用压缩的url进行压缩,压缩效果不会马上看出有延时,好像最多10分钟之内会自动完成。

          // ip:9333/vol/vacuum
         restTemplate.getForObject(Constant.picAccessIpPortWeedFS + "/vol/vacuum", Object.class);
    
    展开全文
  • 分布式文件服务器seadweedfs,以二进制方式存储文件,可上传并下载
  • weedfs_linux_amd64.tar

    2017-07-26 22:51:44
    Lunix64位weefds。
  • weedfs_windows_amd64

    2017-07-26 22:53:50
    64位window版weedfs
  • 一开始安装weedFs的时候一直在最后一步启动服务的时候失败,一开始不明白为啥不能启动,后来发现原先是这个程序是go语言开发的二进制程序,需要先安装go1.9.1.linux-amd64.tar.gz。 1、首先安装配置golang开发环境...

    一开始安装weedFs的时候一直在最后一步启动服务的时候失败,一开始不明白为啥不能启动,后来发现原先是这个程序是go语言开发的二进制程序,需要先安装go1.9.1.linux-amd64.tar.gz。

    1、首先安装配置golang开发环境
    go的最新版本是1.9.1 可到
    https://storage.googleapis.com/golang/go1.9.1.linux-amd64.tar.gz
    下载 go1.9.1.linux-amd64.tar.gz
    2、上传并解压到指定目录 
    sudo tar -xzf go1.9.1.linux-amd64.tar.gz -C /usr/local
    3、配置环境变量
    vim /etc/profile
    export GOROOT=/usr/local/go
    export PATH=$GOROOT/bin:$PATH
    source /etc/profile
    
    4、创建文件夹可以直接从这步开始
    mkdir -p /home/yyt/weedfs/data/ && \
    mkdir -p /home/yyt/weedfs/data/vol1 && \
    mkdir -p /home/yyt/weedfs/data/master && \
    mkdir -p /home/yyt/weedfs/data/filer
    
    rm -rf /home/yyt/weedfs/data && \
    mkdir -p /home/yyt/weedfs/data/master && \
    mkdir -p /home/yyt/weedfs/data/vol1
    
    5、下载weed安装包解压到适当的文件夹
    https://github.com/chrislusf/seaweedfs/releases/tag/0.76
    选择:linux_arm64.tar.gz下载
    解压:tar -zxvf linux_arm64.tar.gz -C /home/yyt/weedfs/
    
    
    
    6、启动master当前目录要使用./weed执行
    nohup /home/yyt/weedfs/weed master -mdir=/home/yyt/weedfs/data/master -port=9333 -ip="172.19.131.45" &>>/home/yyt/weedfs/data/master/master.log &
    
    nohup /home/yyt/weedfs/weed volume -dir="/home/yyt/weedfs/data/vol1" \
    -max=15 \
    -mserver="172.19.131.45:9333" -port=9080 \
    &>>/home/yyt/weedfs/data/vol1/vol1.log &
    
    7、查看
    netstat -lnp | grep 9333
    ps -ef | grep weed
    
    8、测试使用
    curl http://172.19.131.45:9333/dir/assign
    {"fid":"4,02d6944eef","url":"172.19.131.45:9080","publicUrl":"172.19.131.45:9080","count":1}
    

     

    展开全文
  • weedfs文件使用记录

    2020-05-15 17:18:15
    源码目录结构 核心模块 weed 入口目录 ... topology 核心模块,主要包括 【DataCenter, Rack, DataNode】 三层拓扑结构。 storage 核心模块,主要包括【Store, Volume, Needle】这三大块存储相关的源码。...

    源码目录结构

    核心模块

    • weed 入口目录
    • weed/weed_server 入口目录与HTTP服务相关
    • topology 核心模块,主要包括 【DataCenter, Rack, DataNode】 三层拓扑结构。
    • storage 核心模块,主要包括【Store, Volume, Needle】这三大块存储相关的源码。

    辅助模块

    • sequence 负责FileID的全局有序生成
    • filer 提供支持 HTTP REST 操作的文件服务器,其实就是基于 leveldb 把文件名和目录结构存储起来。
    • stats 和操作系统内存和磁盘使用状况有关的模块
    • operation 由protobuf生成的代码们
    • proto 存放protobuf的描述文件
    • glog 日志模块
    • images 图片服务
    • util 工具函数
    • tools 工具,暂时只有一个读索引的文件。

    多数据节点维护之 Topology

    topology 整个模块最核心的数据结构是三个:

    • DataCenter
    • Rack
    • DataNode

    topology 是树状结构,DataNode 是树的叶子节点, DataCenter 和 Rack 是树的非叶子节点, DataCenter 是 Rack 的父母节点。 如下图

     DataCenter | | ------------------ | | | | Rack Rack | | ------------ | | | | DataNode DataNode

    也就是在 MasterServer 维护的拓扑结构里, 是把 VolumeServer 的相关信息存储在 DataNode 里, 所以在代码里面可以看到如下:

    dc := t.GetOrCreateDataCenter(dcName) rack := dc.GetOrCreateRack(rackName) dn := rack.FindDataNode(*joinMessage.Ip, int(*joinMessage.Port))

    每次查找对应的DataNode,都需要从 DataCenter -> Rack -> DataNode 依次找下去。

    数据存储

    理解Fid

    curl -F "file=@/tmp/test.pdf" "127.0.0.1:9333/submit" {"fid":"1,01f96b93eb","fileName":"test.pdf","fileUrl":"localhost:8081/1,01f96b93eb","size":548840}

    其中 "fid":"1,01f96b93eb" 就是 Fid,Fid 由三个部分组成 【VolumeId, NeedleId, Cookie】 组成。

    • VolumeId: 1 32bit 存储的物理卷的Id 
    • NeedleId: 01 64bit 全局唯一NeedleId,每个存储的文件都不一样(除了互为备份的)。
    • Cookie: f96b93eb 32bit Cookie值,为了安全起见,防止恶意攻击。

    其中 VolumeId 是由 MasterServer 分配给 VolumeServer, 每个 VolumeServer 都维护个 n 个 Volume , 每个 Volume 都有一个专属 VolumeId,之后会细说。 Needle 属于 Volume 里面的一个单元,后续说。

    Volume

    type Volume struct { Id VolumeId dir string Collection string dataFile *os.File nm NeedleMapper readOnly bool SuperBlock accessLock sync.Mutex lastModifiedTime uint64 //unix time in seconds }
    • VolumeId 通俗易懂,比如 "fid":"3,01f9896771" 里面逗号前面的 3 就是 VolumeId 。
    • dir 就是该 Volume 所在的目录,
    • Collection 很有用,每个 Volume 只能对应同一个 Collection,不同 Collection 的图片存储在不同 Volume,后面会讲到。
    • 所以同一个 Volume 只能针对某一个 Collection ,而 同一个 Collection 的图片可能分布在不同的 Volume。 dataFile 就是对应的文件句柄。
    • nm NeedleMapper 看上去像是个 map ,其实是个列表,包含多个 Needle ,后面会讲到。
    • readOnly 是否只读
    • SuperBlock 超块,后面会讲到。
    • accessLock 互斥锁
    • lastModifiedTime 最近修改时间

    以上最关键的两个点就是 SuperBlock 和 NeedleMapper , 这两者在文件中布局如下:

    +-------------+ |SuperBlock | +-------------+ |Needle1 | +-------------+ |Needle2 | +-------------+ |Needle3 | +-------------+ |Needle ... | +-------------+
     Volume = 1 SuperBlock + n Needle

    SuperBlock

    /* * Super block currently has 8 bytes allocated for each volume. * Byte 0: version, 1 or 2 * Byte 1: Replica Placement strategy, 000, 001, 002, 010, etc * Byte 2 and byte 3: Time to live. See TTL for definition * Rest bytes: Reserved */ type SuperBlock struct { version Version ReplicaPlacement *ReplicaPlacement Ttl *TTL }

    SuperBlock 内维护的数据基本上就是该 Volume 的元数据。

    • ReplicaPlacement : 在后面的 Replication 会讲
    • Ttl :Time To Live 为了定时删除的功能

    【TTL】

    定时删除功能,这个感觉很酷炫,但是在Seaweedfs里面的实现原理很简单, 按 Volume 来进行分块,当每次用户上传一个自带TTL的文件(需要定时删除的文件)时, 会把这个文件存储在合适的 Volume 里面(如何选出合适的 Volume 之后再说), 存储的时候每个文件会带有 TTL 这个属性, 当读取出来之后发现该文件已经过期(超时时间到),则会返回一个 Not Found 结果, 而每个 Volume 维护一个最大超时时间,当这个时间抵达时,说明整个 Volume 所有的文件都超时了, 然后 VolumeServer 通知 MasterServer 这个 Volume 已经被标识为 Dead 状态, 意味着 MasterServer 不会再为这个 Volume 分配新的 Fid。 然后再经过一段合适的时间后由 VolumeServer 将这个 Volume 从磁盘上安全的删除掉。 详细请看在 Seaweedfs 自带的文档 ttl 

    Needle

    /* * A Needle means a uploaded and stored file. * Needle file size is limited to 4GB for now. */ type Needle struct { Cookie uint32 `comment:"random number to mitigate brute force lookups"` Id uint64 `comment:"needle id"` Size uint32 `comment:"sum of DataSize,Data,NameSize,Name,MimeSize,Mime"` Data []byte `comment:"The actual file data"` DataSize uint32 `comment:"Data size"` //version2 Flags byte `comment:"boolean flags"` //version2 NameSize uint8 //version2 Name []byte `comment:"maximum 256 characters"` //version2 MimeSize uint8 //version2 Mime []byte `comment:"maximum 256 characters"` //version2 LastModified uint64 //only store LastModifiedBytesLength bytes, which is 5 bytes to disk Ttl *TTL Checksum CRC `comment:"CRC32 to check integrity"` Padding []byte `comment:"Aligned to 8 bytes"` }

    Needle 结构体里面的 Cookie 和 Id 就是上文提过的 Fid 里面的 Cookie 和 NeedleId, 其他就是一些存储相关的变量,没什么奇淫巧计。就是简单的存储结构而已。

    数据备份之 Replication

    Replication 和 Topology 严重相关, 在配置文件中可以配置多种备份模式,详见 seaweedfs-wiki 

    +-----+---------------------------------------------------------------------------+ |001 |replicate once on the same rack | +-----+---------------------------------------------------------------------------+ |010 |replicate once on a different rack in the same data center | +-----+---------------------------------------------------------------------------+ |100 |replicate once on a different data center | +-----+---------------------------------------------------------------------------+ |200 |replicate twice on two other different data center | +-----+---------------------------------------------------------------------------+

    比如在 001 模式,即在同一个 rack 中的不同 DataNode 中备份一份。 假设在 rack1 中含有 DataNode1, DataNode2, DataNode3 三个数据节点中【随机】选出两个数据节点, 比如选出 DataNode1, DataNode2 然后同时写入这两个数据节点。 假设 rack1 只有一个数据节点的时候,而备份模式是 001 模式, 则无法正常备份,服务会报错。

    注意到,选择备份数据节点的方法是【随机】,所以就会出现从三个数据节点中随机选择两个的情况下,

    curl -v -F "file=@/tmp/test.json" localhost:8081/5,1ce2111f1

    topo.NextVolumeId 负责生成 VolumeId , 负责在 VolumeGrowth 里的时候分配 Volume 的时候, 生成一个全局唯一的新 VolumeId, 在 Weed-fs 中,是支持 多 MasterServer 集群的。 当有多个 MasterServer,生成一个全局唯一的新 VolumeId 是很重要, 在 Weed-fs 中是通过 goraft 来实现的。

    【强一致性】

    Seaweedfs 的备份实现是强一致性的。 当一个 VolumeServer 接受到上传文件的 POST 请求时, 将该文件作为一个 Needle 写入本地 Volume 之后, 会根据该文件所分配的 VolumeId 判断是否需要备份, 如果需要备份,则进行备份(需要请求另外其它的 VolumeServer 服务器)。 过程详见 ReplicatedWrite (topology/store_replicate.go)。 当备份完毕后,再对该 POST 请求进行答复。 所以用户每次上传图片时,当收到了答复之后, 则可以认为此备份已完成。这个和最终一致性不同,属于强一致性。

    上述实现强一致性的过程中, 有个必要条件就是【 VolumeServer 需要知道往其它那些 VolumeServer 备份】。 在 Seaweedfs 的实现中是借助 MasterServer 来实现, 因为备份的基本单位是 Volume, 在 MasterServer 中,对每个 VolumeId 都维护对应的备份机器列表。 可以通过如下示例命令查看:

    curl "localhost:9333/dir/lookup?volumeId=4&pretty=y" { "volumeId": "4", "locations": [ { "url": "127.0.0.1:8081", "publicUrl": "localhost:8081" }, { "url": "127.0.0.1:8080", "publicUrl": "localhost:8080" } ] }

    如上示例中可以看出,对应的 volumeId=4 的 Volume, 可以看出对应的备份机器列表有两台,分别是 "127.0.0.1:8081" 和 "127.0.0.1:8080" 。

    实际上对于每台 VolumeServer 查找其它备份机器的时候, 也是通过如上 HTTP api 向 MasterServer 询问。 只不过不是每次都询问,因为只要询问过了之后就会缓存下来,只有在缓存里面找不到才询问。

    【Collection】

    示例如下:

    启动 MasterServer

    weed master

    启动 VolumeServer

    weed volume -dir="/tmp/data1" -max=5 -mserver="localhost:9333" -port=8080

    申请Fid

    curl "http://127.0.0.1:9333/dir/assign?collection=pictures" {"fid":"4,01d50c6fbf","url":"127.0.0.1:8080","publicUrl":"localhost:8080","count":1}
    curl "http://127.0.0.1:9333/dir/assign?collection=mp3" {"error":"No free volumes left!"}
    curl "http://127.0.0.1:9333/dir/assign?collection=pictures" {"fid":"5,0147ed0fb7","url":"127.0.0.1:8080","publicUrl":"localhost:8080","count":1}

    申请Fid的示例解释:

    1. 因为默认情况下,VolumeServer 启动时, 未申请任何 Volume,当第一次 /dir/assign 的时候, 会分配 Volume,因为 weed volume 的参数 -max=5 所以一次性分配 5 个 Volume ,并且这 5 个 Volume 的 Collection 属性都是 pictures, 甚至可以看到在 ls /tmp/data1 的结果如下:
    /tmp/data1 pictures_1.dat pictures_1.idx pictures_2.dat pictures_2.idx pictures_3.dat pictures_3.idx pictures_4.dat pictures_4.idx pictures_5.dat pictures_5.idx

    可以看出每个卷的文件名以 Collection 来命名。

    2. 因为已有的 5 个 Volume 的 Collection 属性都是 pictures, 所以此时如果需要 /dir/assign 一个非 pictures Collection 的 Fid 时失败,

    3. 当申请一个属于 pictures Collection 的 Fid 成功。

    也就是在每次申请 Fid 时,会针对 Collection 进行检查,来保证存入 Volume 的每个 Needle 所属的 Collection 一致。 在实际应用中可以通过 Collection 来类别的分片。

    【Volume 的大小限制】

    在每次 VolumeServer 向 MasterServer 发送心跳信息的时候, 会在 storage.VolumeInfo.Size 里面注明当前 Volume 的大小信息(Size)。 所以可以以此来限制 Volume 的大小。 如下函数:

    func (vl *VolumeLayout) isWritable(v *storage.VolumeInfo) bool { return uint64(v.Size) < vl.volumeSizeLimit && v.Version == storage.CurrentVersion && !v.ReadOnly }

    当 VolumeInfo.Size 大于 VolumeLayout.volumeSizeLimit 时, 则将该 Volume 标记为不可写。 而 VolumeLayout.volumeSizeLimit 的值可以在启动 MasterServer 的时候配置。 由 weed help master 可知:

    -volumeSizeLimitMB=30000: Master stops directing writes to oversized volumes.

    每个 Volume 的最大 Size 默认是 30G , 而每个 VolumeServer 可以配置 n 个 Volume,根据所在机器不同的硬盘大小配置不同的 n . 由 weed help volume 可知:

    -max="7": maximum numbers of volumes, count[,count]...

    每个 VolumeServer 默认的 Volume 大小是 7 。

    所以默认情况下,当一个 VolumeServer 使用的磁盘超过 7 * 30G = 210G 之后, 该 VolumeServer 属于只读状态, MasterServer 不会再分配新的 Fid 给它。

    但是其实这里会有漏洞,如果此时不通过请求 MasterServer 获取 Fid, 而是直接自己构造 Fid 向 VolumeServer POST 文件的话, VolumeServer 还是会一直接受上传的文件, 直到大小超过在storage/needle.go 里面写死的一个常量:

    MaxPossibleVolumeSize = 4 * 1024 * 1024 * 1024 * 8

    其实在 VolumeServer 里面也有维护一个变量叫 volumeSizeLimit ,

    type Store struct { ... volumeSizeLimit uint64 //read from the master ... }

    此变量的值是从 MasterServer 获取的, 当每次 VolumeServer 写入 Needle 到 Volume 的时候, 都会检查 Volume Size 是否超过 volumeSizeLimit , 当超过的时候会打错误日志, 但是不会停止写入,也就是不会拒绝上传的文件。 有且只有 当大小超过 MaxPossibleVolumeSize 的时候才会拒绝写入磁盘。

    【扩容】

    对于 Seaweedfs 来说,扩容非常简单,

    启动 MasterServer:

    ./weed master -mdir="/tmp/weed_master_tmp"

    启动 VolumeServer1:

    weed volume -dir="/tmp/data1" -max=5 -mserver="localhost:9333" -port=8080

    当 VolumeServer1 因为抵达 Volume 大小上限而无法继续接受上传数据时, 此时继续 submit 上传数据 MasterServer 则会返回错误(因为在 MasterServer 内已经将 VolumeServer1 标记为不可写)。

    curl -F "file=@/tmp/test.pdf" "127.0.0.1:9333/submit" {"error":"No free volumes left!"}

    此时直接再启动 VolumeServer2 即可

    weed volume -dir="/tmp/data2" -max=5 -mserver="localhost:9333" -port=8081

    此时 VolumeServer2 启动之后会自动向 MasterServer 的 Topology 结构注册新的 DataNode , 当 MasterServer 接受到新的 submit 请求的时候,会将该上传文件写入 VolumeServer2 (因为此时 VolumeServer1 已经不可写)。

    也就是说如果当线上出现容量问题的时候,扩容只需要加机器即可,简单有效。

    总结

    • 每个 MasterServer 通过 Topology 维护多个 VolumeServer 。
    • 每个 VolumeServer 维护多个 Volume 。
    • 每个 Volume 包含多个 Needle ,Needle 即文件。
    • 多台 VolumeServer 之间的多机备份实现是强一致性。
    • 多台 MasterServer 之间的主从关系是是通过 goraft 实现。
    • 1.架构

      我们先了解一个概念:见附录

      一个master:

      作为cluster管理一个DataCenter名叫imgdatacenter1(抽象的概念);
      imgdatacenter1包含一个机柜 rack名叫imgrack1(抽象的概念);
      imgrack1机柜里面有一个DataNode名叫datanode1(可以认为DataNode是一个volume server );

       

      cd /home1/seaweeddir  //这是我的测试目录,你这里选择你自己的目录
      mkdir {mtmp,vtmp1,vtmp2,ftmp,mountdir}  //大括号内千万别多空格,否则会出现问题
      weed master -ip=localhost -port=9333 -mdir=./mtmp (mtmp是你自定义的保存生成的序列文件id的文件夹)
      

      一个DataNode:(datanode1只是抽象的名字没有实质的代码赋值,下面通过地址来区分DataNode)

      就是上面的datanode1,定义里面有10个volume,collection不先设置,DataCenter和rack都用下面的指令指定:

       

      weed volume  -dataCenter=imgdatacenter1 -rack=imgrack1  -ip=localhost -port=9991 -dir=./vtmp1 -max=10 -mserver=localhost:9333
      

      此时就在名为imgdatacenter1的dataCenter中的名为imgrack1的rack里添加了一个地址为localhost:9991的volume server。

      一个filer服务器

       

      weed scaffold -config=filer -output=.      //先生成filer.toml文件
      

      默认使用leveldb保存映射关系,打开filer.toml文件修改保存映射文件的文件夹为ftmp(自定义)

       

      image.png

       

      然后启动filer服务

       

      weed filer -ip=localhost -port=8888  -master=localhost:9333 
      

      本地映射filer

      mountdir 是本地任意目录,filer.path后面跟你想映射的filer中的目录,可以直接映射根目录。

       

      sudo weed mount -filer=localhost:8888 -dir=/home1/seaweeddir/mountdir -filer.path=/  
      //sudo weed mount -filer=localhost:8888 -dir=~/folder_on_seaweedfs -filer.path=/home/chris -collection=chris
      

      关闭挂在需要关闭mount并且手动umont ~/mdir目录,如果一般用户失败请使用root用户

      2.验证

      我们验证下我们的服务启动状态,
      此时有一个DataCenters名为imgdatacenter1,一个Racks名为imgrack1,一个DataNodes地址是localhost:9991,且该DataNode的Volumes个数为0,等我们新增文件的时候就会发现volumes个数才会增加

       

      //这种返回表示master启动成功且作为了leader
      curl "http://localhost:9333/cluster/status?pretty=y"
      {
        "IsLeader": true,
        "Leader": "localhost:9333"
      }
      
      //此时有一个DataCenters名为imgdatacenter1,一个Racks名为imgrack1,一个DataNodes地址是localhost:9991,且该DataNode的Volumes个数为0
      curl "http://localhost:9333/dir/status?pretty=y"
      {
        "Topology": {
          "DataCenters": [
            {
              "Free": 10,
              "Id": "imgdatacenter1",
              "Max": 10,
              "Racks": [
                {
                  "DataNodes": [
                    {
                      "Free": 10,
                      "Max": 10,
                      "PublicUrl": "localhost:9991",
                      "Url": "localhost:9991",
                      "Volumes": 0
                    }
                  ],
                  "Free": 10,
                  "Id": "imgrack1",
                  "Max": 10
                }
              ]
            }
          ],
          "Free": 10,
          "Max": 10,
          "layouts": null
        },
        "Version": "1.10"
      }
      

      本地操作的方式往服务器新增一个文件

       

      cd /home1/image/mountdir
      cp /home1/image/1.jpg ./
      

      我们查看下系统状态,(详细数据参见附录:上传文件后的系统状态)
      此时我们发现地址为localhost:9991的datanode的Volumes数量变成了7个,说明当前新增了7个volume,因为我们之前设置的volume最大个数时10,所有最多还能再新增3个volume。
      我们再看layouts,发现已经不是之前的null了,而是出现了一个名为""的collection,有七个可以写的volume。
      这是因为如果我们没有指定collection的时候,默认所有数据都保存在名为""的collection中

      我们查看下文件上传后volumeserver的状态
      我们发现id为4的volume的filecount为1,说明该文件上传到了这里。

      我们你再看下filer的状态
      多了个1.jpg文件

      我们再看下我们的挂载目录

       

      ls /home1/seaweeddir/mountdir/
      1.jpg
      

      此时说明我们上传文件就成功了

      此时我们可以操作本地文件系统中的目录/home1/seaweeddir/mountdir,来操作我们的图片服务器。
      然而批量操作本地文件系统的mount文件夹时不是并发的,需要经过fuse层,要想并发操作就需要直接操作filer服务。

      通过filer服务器做一些文件操作

      使用命令上传

       

      curl -F file=@report.js "http://localhost:8888/javascript/new_name.js"    # upload the file with a different name
      

      本地批量上传文件

      使用weed filer.copy file_or_dir1 [file_or_dir2 file_or_dir3] http://localhost:8888/path/to/a/folder/ (多线程且绕过fuse层)
      我在本地/home1/image/staff 下有大量的图片,这里上传到filer服务器的mystaff下,我们查看/home1/seaweeddir/mountdir/下,会发现多了个staff目录,且目录下也全部拷贝了图片。

       

      weed filer.copy /home1/image/staff http://localhost:8888/mystaff
      

      删除文件

       

      curl -X DELETE http://localhost:8888/path/to/file
      

      删除文件夹

       

      curl -X DELETE http://localhost:8888/path/to/dir?recursive=true
      

      一些注意事项

      1.关闭volume mount时需要手动sudo mount -l /home1/seaweeddir/mountdir目录,否则该目录会导致终端卡死。
      2.删除操作不会马上清空磁盘,要想实时清空未使用的空间,请执行
      curl "http://localhost:9333/vol/vacuum"

      使用fid操作文件在filer的显示

       

      curl http://localhost:9333/dir/assign
      {"fid":"7,03a0146c8ac8","url":"localhost:9991","publicUrl":"localhost:9991","count":1}
      
      curl -F file=@/home1/image/1.jpg http://localhost:9991/7,03a0146c8ac8 //在filer中找不到,因为filer服务没有保存映射关系,所有想使用filer,就得使用filer上传文件,否则只能通过fid获取信息。
      curl -F file=@/home1/image/1.jpg "http://localhost:8888/javascript/2.jpg"//在filer的javascript目录下多了个2.jpg
      
      weed download -server="localhost:9333" -dir="D:\data3" 4,012d48fa67 //可以通过fid下载文件
      

      结尾

      到这里一个图片服务器就搭建起来了,
      真正要熟悉使用seaweedfs需要仔细阅读官方wiki,并且查看源码和实现依赖的论文来了解实现原理。
      剩余的像数据备份,服务器云备份等请看官网wiki:
      https://github.com/chrislusf/seaweedfs/wiki/Failover-Master-Server
      https://github.com/chrislusf/seaweedfs/wiki/Amazon-S3-API
      https://github.com/chrislusf/seaweedfs/wiki/Async-Replication-to-another-Filer

      总结

       

      cd /home1/seaweeddir 
      mkdir {mtmp,vtmp1,vtmp2,ftmp,mountdir} 
      weed scaffold -config=filer -output=. 
      vim filer.toml (修改leveldb的dir为"./ftmp")
      weed master -ip=localhost -port=9333 -mdir=./mtmp
      weed volume  -dataCenter=imgdatacenter1 -rack=imgrack1  -ip=localhost -port=9991 -dir=./vtmp1 -max=10 -mserver=localhost:9333
      weed filer -ip=localhost -port=8888  -master=localhost:9333 -collection=test
      sudo weed mount -filer=localhost:8888 -dir=/home1/seaweeddir/mountdir -filer.path=/   -collection=test
      //关闭服务后执行 sudo umount -l /home1/seaweeddir/mountdir 取消挂载
      //此时就可以使用filer通过web操作文件了,而且也可以通过/home1/seaweeddir/mountdir本地操作文件了。
      //或者这么理解,sudo weed mount只能用sudo umount -l 取消挂载,而不是直接kill进程。
      

      附录:

      其他上传下载的命令

       

      weed upload -master=localhost:9333 file1 [file2 file3]
      weed upload -master=localhost:9333 -dir=one_directory -include=*.pdf
      

       

      //指定几个fid下载到本地one_directory中
      weed download -server=localhost:9333 -dir=one_directory fid1 [fid2 fid3 ...]
      

       

      //导出id为7的volume到/dir/name.tar,/tmp是volume保存的地址,只导出比2006-01-02T15:04:05新的文件
      weed export -dir=/tmp -volumeId=7 -o=/home1/seaweeddir/exp2/name.tar -fileNameFormat={{.Name}} -newer='2006-01-02T15:04:05'
      

      一些概念

      1.topology 是树状结构,DataNode 是树的叶子节点, DataCenter 和 Rack 是树的非叶子节点, DataCenter 是 Rack 的父母节点。
      2.在 MasterServer 维护的拓扑结构里, 是把 VolumeServer 的相关信息存储在 DataNode 里,每次查找对应的DataNode,都需要从 DataCenter -> Rack -> DataNode 依次找下去。
      3."fid":"1,01f96b93eb" 就是 Fid,Fid 由三个部分组成 【VolumeId, NeedleId, Cookie】 组成

       

          VolumeId: 1 32bit 存储的物理卷的Id 
          NeedleId: 01 64bit 全局唯一NeedleId,每个存储的文件都不一样(除了互为备份的)。
          Cookie: f96b93eb 32bit Cookie值,为了安全起见,防止恶意攻击
      

      4.VolumeId 是由 MasterServer 分配给 VolumeServer, 每个 VolumeServer 都维护个 n 个 Volume , 每个Volume 都有一个专属 VolumeId,之后会细说。 Needle 属于 Volume 里面的一个单元
      5.dir 就是该 Volume 所在的目录,
      6.Collection 很有用,每个 Volume 只能对应同一个 Collection,不同 Collection 的图片存储在不同 Volume,所以同一个 Volume 只能针对某一个 Collection ,而 同一个 Collection 的图片可能分布在不同的 Volume
      7.Replication 和 Topology 严重相关,比如在 001 模式,即在同一个 rack 中的不同 DataNode 中备份一份。假设在 rack1 中含有 DataNode1, DataNode2, DataNode3 三个数据节点中【随机】选出两个数据节点, 比如选出 DataNode1, DataNode2 然后同时写入这两个数据节点。 假设 rack1 只有一个数据节点的时候,而备份模式是 001 模式, 则无法正常备份,服务会报错。
      8.VolumeServer 启动时, 未申请任何 Volume,当第一次 /dir/assign 的时候, 会分配 Volume
      9.每个 VolumeServer 默认的 Volume 大小是 7 。默认情况下,当一个 VolumeServer 使用的磁盘超过 7 *30G = 210G 之后, 该 VolumeServer 属于只读状态, MasterServer 不会再分配新的 Fid 给它。
      10.每个 MasterServer 通过 Topology 维护多个 VolumeServer 。
      11.每个 VolumeServer 维护多个 Volume 。
      12.每个 Volume 包含多个 Needle ,Needle 即文件。
      13.多台 VolumeServer 之间的多机备份实现是强一致性。
      14.多台 MasterServer 之间的主从关系是是通过 goraft 实现。

      collection的说明

      如果我们没有指定collection的时候,默认所有数据都保存在名为""的collection中,
      0.按照collection删除

       

      Delete Collection
      curl "http://localhost:9333/col/delete?collection=xxx&pretty=y"
      

      1.预申请volume的时候指定collection

       

      //预申请4个属于名为turbo的collection 的volume
      curl "http://localhost:9333/vol/grow?collection=turbo&count=4"
      

      2.添加filer时指定collection

       

      //此时所有通过filer新增的数据都在名为myfiler的collection中
      weed filer -ip=localhost -port=8888  -master=localhost:9333  -collection=myfiler
      
    • mount时指定collection
    •  

      //只挂在指定collection
      weed mount -filer=localhost:8888 -dir=~/folder_on_seaweedfs -filer.path=/home/chris -collection=chris
      

      4.其他

       

      curl "http://127.0.0.1:9333/dir/assign?collection=pictures"
      curl -F @file=./hello1.txt http://10.0.40.58:9333/submit?collection=test_crash
      weed upload -collection myfiles -master=localhost:9333 XXX.txt
      

      上传文件后的系统状态

       

      curl "http://localhost:9333/dir/status?pretty=y"
      {
        "Topology": {
          "DataCenters": [
            {
              "Free": 3,
              "Id": "imgdatacenter1",
              "Max": 10,
              "Racks": [
                {
                  "DataNodes": [
                    {
                      "Free": 3,
                      "Max": 10,
                      "PublicUrl": "localhost:9991",
                      "Url": "localhost:9991",
                      "Volumes": 7
                    }
                  ],
                  "Free": 3,
                  "Id": "imgrack1",
                  "Max": 10
                }
              ]
            }
          ],
          "Free": 3,
          "Max": 10,
          "layouts": [
            {
              "collection": "",
              "replication": "000",
              "ttl": "",
              "writables": [
                1,
                2,
                3,
                4,
                5,
                6,
                7
              ]
            }
          ]
        },
        "Version": "1.10"
      }
      

      我们查看下文件上传后volumeserver的状态
      我们发现id为4的volume的filecount为1,说明该文件上传到了这里。

       

      curl "http://localhost:9991/status?pretty=y"
      {
        "Version": "1.10",
        "Volumes": [
          {
            "Id": 1,
            "Size": 0,
            "ReplicaPlacement": {
              "SameRackCount": 0,
              "DiffRackCount": 0,
              "DiffDataCenterCount": 0
            },
            "Ttl": {},
            "Collection": "",
            "Version": 3,
            "FileCount": 0,
            "DeleteCount": 0,
            "DeletedByteCount": 0,
            "ReadOnly": false
          },
          {
            "Id": 2,
            "Size": 0,
            "ReplicaPlacement": {
              "SameRackCount": 0,
              "DiffRackCount": 0,
              "DiffDataCenterCount": 0
            },
            "Ttl": {},
            "Collection": "",
            "Version": 3,
            "FileCount": 0,
            "DeleteCount": 0,
            "DeletedByteCount": 0,
            "ReadOnly": false
          },
          {
            "Id": 3,
            "Size": 0,
            "ReplicaPlacement": {
              "SameRackCount": 0,
              "DiffRackCount": 0,
              "DiffDataCenterCount": 0
            },
            "Ttl": {},
            "Collection": "",
            "Version": 3,
            "FileCount": 0,
            "DeleteCount": 0,
            "DeletedByteCount": 0,
            "ReadOnly": false
          },
          {
            "Id": 4,
            "Size": 77285,
            "ReplicaPlacement": {
              "SameRackCount": 0,
              "DiffRackCount": 0,
              "DiffDataCenterCount": 0
            },
            "Ttl": {},
            "Collection": "",
            "Version": 3,
            "FileCount": 1,
            "DeleteCount": 0,
            "DeletedByteCount": 0,
            "ReadOnly": false
          },
          {
            "Id": 5,
            "Size": 0,
            "ReplicaPlacement": {
              "SameRackCount": 0,
              "DiffRackCount": 0,
              "DiffDataCenterCount": 0
            },
            "Ttl": {},
            "Collection": "",
            "Version": 3,
            "FileCount": 0,
            "DeleteCount": 0,
            "DeletedByteCount": 0,
            "ReadOnly": false
          },
          {
            "Id": 6,
            "Size": 0,
            "ReplicaPlacement": {
              "SameRackCount": 0,
              "DiffRackCount": 0,
              "DiffDataCenterCount": 0
            },
            "Ttl": {},
            "Collection": "",
            "Version": 3,
            "FileCount": 0,
            "DeleteCount": 0,
            "DeletedByteCount": 0,
            "ReadOnly": false
          },
          {
            "Id": 7,
            "Size": 0,
            "ReplicaPlacement": {
              "SameRackCount": 0,
              "DiffRackCount": 0,
              "DiffDataCenterCount": 0
            },
            "Ttl": {},
            "Collection": "",
            "Version": 3,
            "FileCount": 0,
            "DeleteCount": 0,
            "DeletedByteCount": 0,
            "ReadOnly": false
          }
        ]
      }
      

      我们你再看下filer的状态
      多了个1.jpg文件

       

      curl  -H "Accept: application/json" "http://localhost:8888/?pretty=y" 
      {
        "Path": "",
        "Entries": [
          {
            "FullPath": "/1.jpg",
            "Mtime": "2018-12-18T10:38:18+08:00",
            "Crtime": "2018-12-18T10:38:18+08:00",
            "Mode": 436,
            "Uid": 1000,
            "Gid": 1000,
            "Mime": "image/jpeg",
            "Replication": "",
            "Collection": "",
            "TtlSec": 0,
            "chunks": [
              {
                "file_id": "4,0189b08312",
                "size": 77244,
                "mtime": 1545100698715493243,
                "e_tag": "32f4abc5"
              }
            ]
          }
        ],
        "Limit": 100,
        "LastFileName": "1.jpg",
        "ShouldDisplayLoadMore": false
      }
      

      我们再看下我们的挂载目录

       

      ls /home1/seaweeddir/mountdir/
      1.jpg


       

    展开全文
  • 最近拿一台双核1G的kvm vps搭建了一个图片的服务器,前面用百度云加速扛着...总结一下最近接触过的两个分布式小文件系统weedfs和fastdfs。 fastdfs的详细介绍看这里=》 传送门 weedfs官方地址= &gt;传送门...

    https://www.tuicool.com/articles/uaiimu

    最近拿一台双核1G的kvm vps搭建了一个图片的服务器,前面用百度云加速扛着,有了个专业图片存储及CDN的样子。每天还是有50W左右的PV,流量在30G左右。总结一下最近接触过的两个分布式小文件系统weedfs和fastdfs。

    fastdfs的详细介绍看这里=》 传送门

    weedfs官方地址= >传送门

    在两个系统中都有一个负责管理存储节点或者存储卷的服务,weedfs中叫master,而fastdfs中叫做tracker。下面是在文档中对各自的master的解释

     

     

     

     

     

     

    PHP

     

    FastDFS服务端有两个角色:跟踪器(tracker)和存储节点(storage)。跟踪器主要做调度工作,在访问上起负载均衡的作用。
    
    
    Weed-FS的master server选择管理数据卷(data volumes)而不是数据块,每个数据卷大小是32GB,能够保存大量的文件( 小文件 ),每个存储节点能够拥有很多个数据卷,master节点只需要保存这些卷的元数据就可以了,并且这些数据量很少,并且大部分情况下是很少会变化的。 
    所有的卷都由master服务器来管理,master服务器包含了卷id和卷服务器的mapping,这些信息基本不变,可以很好的缓存起来。

     

    FastDFS 服务端有两个角色:跟踪器( tracker )和存储节点( storage )。跟踪器主要做调度工作,在访问上起负载均衡的作用。

    Weed - FS 的 master server 选择管理数据卷( data volumes )而不是数据块,每个数据卷大小是 32GB ,能够保存大量的文件( 小文件 ),每个存储节点能够拥有很多个数据卷, master节点只需要保存这些卷的元数据就可以了,并且这些数据量很少,并且大部分情况下是很少会变化的。

    所有的卷都由 master 服务器来管理, master 服务器包含了卷 id 和卷服务器的 mapping ,这些信息基本不变,可以很好的缓存起来。

    根据上面的解释就可以知道,master在上传和下载文件的过程中都承载着定位文件需要上传或者下载的具体的卷。

    在具体存储小文件的时候,weedfs是通过将多个小文件的二级制存储到一个大文件中,然后通过索引进行具体的位置的定位。而fastdfs是通过文件夹散列的方式将文件直接存储在硬盘上面。但从这里就可以看出来,在海量小文件的情况下,weedfs产生的文件的元数据是很少的,因他他至于每个数据卷的元数据。而weedfs会产生大量的元数据,因为他依赖的是操作系统的文件管理系统,对每一个文件的定位以及验证都是通过元数据来进行的。

    从上面的对比就可以看出来,在海量小文件的情况下肯定是weedfs的性能更高,因为他的文件元数据是相当少的,所以这部分经常被访问的元数据能够被操作系统或者内存直接缓存住,这样就减少了对磁盘的操作,而磁盘的操作只需要进行一次,就是在进行文件读取的时候。而fastdfs回产生海量的文件的元数据,大到一定程序了操作系统的缓存或者内存就无法进行全部存储了,这样就造成了在硬盘上进行随机读写来查找文件了,两个效率和速度以及对系统和硬盘造成的负载显而易见了。

    总结:小文件存储不同于大文件,大文件的性能和时间消耗,主要在传输的带宽等限制上。而小文件主要在于系统本身的读取速度上。所以综合来说,个人觉得weedfs比fastdfs更先进,更能承受数量更大的小文件

    展开全文
  • minio与weedfs支持S3功能

    2021-08-04 16:47:09
  • weedfs client

    2019-07-28 20:56:54
    weedFS Client For Java Features SeaweedFSis a simple and highly scalable distributed file system and started by implementingFacebook's Haystack design paper. SeaweedFS is currently growing, with m.....
  • weedfs是一个适用于需要存储大量小文件的一个分布式文件系统,全名为Seaweed-fs,是一个使用go语言开发的简单的高可用的系统。开创之初weedfs是源于一篇Facebook的论文实现,下面介绍在服务器中的安装部署步骤。一、...
  • centos weedfs安装配置

    千次阅读 2017-11-16 14:29:24
    下载 https: //github .com /chrislusf/seaweedfs/releases/download/ 0.76 /linux_amd64 .tar .gz 这里下载 linux_amd64版本 ...weedfs 操作 详见官方文档: https://github.com/chrislusf/seaweedfs
  • WeedFS问题收集

    2019-10-05 12:01:04
    weed fs FAQ Moving files to a different server Q: Hello,is it possible to move manually the .dat and .idx to a different volume? ...Moving it to a different volume server?... Steps: 1....
  • WeedFS依赖库 0.6.1

    2019-10-05 12:01:05
    WeedFS依赖库 版本 0.6.1 =======================================================================glog=======================================================================...
  • 将图片的上传,分布式管理 交由seaweedfs管理,可提供更快的响应速度,更方便,无痛的分布式扩展节点,billion 级别的。后面使用openresty + lua-resty-weedfs + graphicsmagick 生成缩略图功能独立处理。
  • WeedFS0.6.8-引用库列表

    2019-10-05 12:03:31
    WeedFS 0.68新增了对cassandra数据库存储的支持及JSON Web Token(JWTs)安全的支持. github.com/gocql/gocql //filer/cassandra_store/cassandra_store.go github....
  • weedfs

    2015-10-27 13:54:28
  • mv ~/woring/lua-resty-weedfs/weedfs.lua ./weedfs.lua 创建 www-data 组和用户,创建路径/home/wwwroot/weedfs. nginx.conf 如下: user www-data www-data; worker_processes 8; daemon on; master_...
  • 启动master weed master -ip 10.191.197.133 -mdir /namenode -ip.bind 10.191.197.133 I0809 16:53:51 7721 file_util.go:20] Folder /namenode Permission: -rwxr-xr-x I0809 16:53:51 7721 master_serv...
  • Nginx+Lua+WeedFS安装手记

    千次阅读 2016-06-13 10:09:09
    安装手记 首先下载WeedFS https://bintray.com/chrislusf/Weed-FS/weed 下载最新的WeedFS Server tar zxvf weed_0.57_linux_amd64.tar.gz 启动Master server 以及 volume ser
  • WeedFS 源码分析

    2015-01-11 08:18:03
    /storage/volume_ttl.go type TTL struct { count byte unit byte } 由数值和单位构成,从说明文档来看,单位支持m, h, d, w, M, y。 .../storage/replica_placement.go ...type ReplicaPlacement s...

空空如也

空空如也

1 2 3 4 5 6
收藏数 115
精华内容 46
关键字:

weedfs