作者： pbdatacn

使用Docker搭建zabbix平台

1.准备安装好zabbix服务的镜像

我们选择的是docker.io/berngp/docker-zabbix镜像作为扩展：

docker pull docker.io/berngp/docker-zabbix

下载镜像如下所示：

docker pull docker.io/berngp/docker-zabbix

2.宿主机中启动Docker

docker启动zabbix时，需要绑定宿主机的端口，启动命令如下:

docker run -d \
          -p 10051:10051 \
          -p 10052:10052 \
          -p 7777:80       \
          -p 2812:2812   \
          --name zabbix  \
          berngp/docker-zabbix

2017年9月25日

手动搭建kubernetes1.7.5集群

ip	组件	备注
192.168.151.41	kube-api-server kube-controller kube-schedular etcd
192.168.151.40	etcd flannel docker kubelet kube-proxy
192.168.151.38	etcd

参考文档： kubernetes-handbook

软件依赖

golang，略过
cfssl，证书相关

$ go get -u github.com/cloudflare/cfssl/cmd/cfssl
$ go get -u github.com/cloudflare/cfssl/cmd/...

cfssl的使用请参考： cfssl使用文档

CA

$ mkdir /root/zhaoming9/ssl
$ cd /root/zhaoming9/ssl
$ cfssl print-defaults config > config.json
$ cfssl print-defaults csr > csr.json
# 根据config.json文件的格式创建如下的ca-config.json文件
# 过期时间设置成了 87600h
$ cat > ca-config.json <<EOF
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "kubernetes": {
        "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ],
        "expiry": "87600h"
      }
    }
  }
}
EOF

kubernetes证书

$ vi kubernetes-csr.json
{
    "CN": "kubernetes",
    "hosts": [
      "127.0.0.1",
      "192.168.151.41",
      "192.168.151.40",
      "192.168.151.38",
      "192.168.151.33",
      "10.1.0.1",
      "kubernetes",
      "kubernetes.default",
      "kubernetes.default.svc",
      "kubernetes.default.svc.cluster",
      "kubernetes.default.svc.cluster.local"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "BeiJing",
            "L": "BeiJing",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
$ cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kubernetes-csr.json | cfssljson -bare kubernetes 

admin证书

$ vi admin-csr.json
{
  "CN": "admin",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "system:masters",
      "OU": "System"
    }
  ]
}
$ cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes admin-csr.json | cfssljson -bare admin

kube-proxy证书

$ vi kube-proxy-csr.json
{
  "CN": "system:kube-proxy",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "k8s",
      "OU": "System"
    }
  ]
}
$ cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes  kube-proxy-csr.json | cfssljson -bare kube-proxy

证书分发

$ mkdir -p /etc/kubernetes/ssl
$ cp *.pem /etc/kubernetes/ssl

每台主机都相同

ETCD集群安装

$ wget https://github.com/coreos/etcd/releases/download/v3.2.7/etcd-v3.2.7-linux-amd64.tar.gz
$ tar xzvf etcd-v3.2.7-linux-amd64.tar.gz
$ mv etcd-v3.2.7-linux-amd64/etcd* /usr/local/bin
$ vi /etc/systemd/system/etcd.service
[Unit]
Description=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target
Documentation=https://github.com/coreos
[Service]
Type=notify
WorkingDirectory=/var/lib/etcd/
EnvironmentFile=-/etc/etcd/etcd.conf
ExecStart=/usr/local/bin/etcd \
  --name ${ETCD_NAME} \
  --cert-file=/etc/kubernetes/ssl/kubernetes.pem \
  --key-file=/etc/kubernetes/ssl/kubernetes-key.pem \
  --peer-cert-file=/etc/kubernetes/ssl/kubernetes.pem \
  --peer-key-file=/etc/kubernetes/ssl/kubernetes-key.pem \
  --trusted-ca-file=/etc/kubernetes/ssl/ca.pem \
  --peer-trusted-ca-file=/etc/kubernetes/ssl/ca.pem \
  --initial-advertise-peer-urls ${ETCD_INITIAL_ADVERTISE_PEER_URLS} \
  --listen-peer-urls ${ETCD_LISTEN_PEER_URLS} \
  --listen-client-urls ${ETCD_LISTEN_CLIENT_URLS},http://127.0.0.1:2379 \
  --advertise-client-urls ${ETCD_ADVERTISE_CLIENT_URLS} \
  --initial-cluster-token ${ETCD_INITIAL_CLUSTER_TOKEN} \
  --initial-cluster ${ETCD_INITIAL_CLUSTER} \
  --initial-cluster-state new \
  --data-dir=${ETCD_DATA_DIR}
Restart=on-failure
RestartSec=5
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target
$ vi /etc/etcd/etcd.conf
# [member]
ETCD_NAME=infra1
ETCD_DATA_DIR="/var/lib/etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.151.41:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.151.41:2379"
# [cluster]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.151.41:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER="infra1=https://192.168.151.41:2380,infra2=https://192.168.151.40:2380,infra3=https://192.168.151.38:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.151.41:2379"
$ systemctl daemon-reload
$ systemctl enable etcd
$ systemctl start etcd
$ stemctl status etcd
$ etcdctl \
  --ca-file=/etc/kubernetes/ssl/ca.pem \
  --cert-file=/etc/kubernetes/ssl/kubernetes.pem \
  --key-file=/etc/kubernetes/ssl/kubernetes-key.pem \
  cluster-health

kubernetes

$ cd /root/zhaoming9
$ wget https://github.com/kubernetes/kubernetes/releases/download/v1.7.5/kubernetes.tar.gz
$ tar xzvf kubernetes.tar.gz

kubectl kubeconfig

$ export KUBE_APISERVER="https://192.168.151.41:6443"
# 设置集群参数
$ kubectl config set-cluster kubernetes \
  --certificate-authority=/etc/kubernetes/ssl/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER}
# 设置客户端认证参数
$ kubectl config set-credentials admin \
  --client-certificate=/etc/kubernetes/ssl/admin.pem \
  --embed-certs=true \
  --client-key=/etc/kubernetes/ssl/admin-key.pem
# 设置上下文参数
$ kubectl config set-context kubernetes \
  --cluster=kubernetes \
  --user=admin
# 设置默认上下文
$ kubectl config use-context kubernetes

kube-apiserver

$ vi /etc/systemd/system/kube-apiserver.service
[Unit]
Description=Kubernetes API Service
Documentation=https://github.com/kubernetes/kubernetes
After=network.target
After=etcd.service
[Service]
EnvironmentFile=-/etc/kubernetes/config
EnvironmentFile=-/etc/kubernetes/apiserver
ExecStart=/usr/local/bin/kube-apiserver \
        $KUBE_LOGTOSTDERR \
        $KUBE_LOG_LEVEL \
        $KUBE_ETCD_SERVERS \
        $KUBE_API_ADDRESS \
        $KUBE_API_PORT \
        $KUBELET_PORT \
        $KUBE_ALLOW_PRIV \
        $KUBE_SERVICE_ADDRESSES \
        $KUBE_ADMISSION_CONTROL \
        $KUBE_API_ARGS
Restart=on-failure
Type=notify
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target
 
$ vi /etc/kubernetes/config
###
# kubernetes system config
#
# The following values are used to configure various aspects of all
# kubernetes services, including
#
#   kube-apiserver.service
#   kube-controller-manager.service
#   kube-scheduler.service
#   kubelet.service
#   kube-proxy.service
# logging to stderr means we get it in the systemd journal
KUBE_LOGTOSTDERR="--logtostderr=true"
# journal message level, 0 is debug
KUBE_LOG_LEVEL="--v=0"
# Should this cluster be allowed to run privileged docker containers
KUBE_ALLOW_PRIV="--allow-privileged=true"
# How the controller-manager, scheduler, and proxy find the apiserver
KUBE_MASTER="--master=http://192.168.151.41:8080"
 
$ vi /etc/kubernetes/apiserver
###
## kubernetes system config
##
## The following values are used to configure the kube-apiserver
##
#
## The address on the local server to listen to.
KUBE_API_ADDRESS="--advertise-address=192.168.151.41 --bind-address=192.168.151.41 --insecure-bind-address=192.168.151.41"
#
## The port on the local server to listen on.
KUBE_API_PORT="--insecure-port=8080 --secure-port=6443"
#
## Port minions listen on
#KUBELET_PORT="--kubelet-port=10250"
#
## Comma separated list of nodes in the etcd cluster
KUBE_ETCD_SERVERS="--etcd-servers=https://192.168.151.41:2379,https://192.168.151.40:2379,https://192.168.151.38:2379 --etcd-cafile=/etc/kubernetes/ssl/ca.pem --etcd-certfile=/etc/kubernetes/ssl/kubernetes.pem --etcd-keyfile=/etc/kubernetes/ssl/kubernetes-key.pem"
#
## Address range to use for services
KUBE_SERVICE_ADDRESSES="--service-cluster-ip-range=10.1.0.0/16"
#
## default admission control policies
KUBE_ADMISSION_CONTROL="--admission-control=ServiceAccount,NamespaceLifecycle,NamespaceExists,LimitRanger,ResourceQuota"
#
## Add your own!
KUBE_API_ARGS="--authorization-mode=RBAC --runtime-config=rbac.authorization.k8s.io/v1beta1 --service-node-port-range=30000-32767 --tls-cert-file=/etc/kubernetes/ssl/kubernetes.pem --tls-private-key-file=/etc/kubernetes/ssl/kubernetes-key.pem --client-ca-file=/etc/kubernetes/ssl/ca.pem --service-account-key-file=/etc/kubernetes/ssl/ca-key.pem  --enable-swagger-ui=true --apiserver-count=3 --audit-log-maxage=30 --audit-log-maxbackup=3 --audit-log-maxsize=100 --audit-log-path=/var/lib/audit.log --event-ttl=1h --kubelet-https=true  --kubelet-certificate-authority=/etc/kubernetes/ssl/ca.pem --kubelet-client-certificate=/etc/kubernetes/ssl/kubernetes.pem --kubelet-client-key=/etc/kubernetes/ssl/kubernetes-key.pem"
 
$ systemctl daemon-reload
$ systemctl enable kube-apiserver
$ systemctl start kube-apiserver
$ systemctl status kube-apiserver

kube-controler-manager

$ vi /etc/systemd/system/kube-controller-manager.service
[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/kubernetes/kubernetes
[Service]
EnvironmentFile=-/etc/kubernetes/config
EnvironmentFile=-/etc/kubernetes/controller-manager
ExecStart=/usr/local/bin/kube-controller-manager \
        $KUBE_LOGTOSTDERR \
        $KUBE_LOG_LEVEL \
        $KUBE_MASTER \
        $KUBE_CONTROLLER_MANAGER_ARGS
Restart=on-failure
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target
$ vi /etc/kubernetes/controller-manager
###
# The following values are used to configure the kubernetes controller-manager
# defaults from config and apiserver should be adequate
# Add your own!
KUBE_CONTROLLER_MANAGER_ARGS="--address=127.0.0.1 --service-cluster-ip-range=10.1.0.0/16 --cluster-name=kubernetes --cluster-signing-cert-file=/etc/kubernetes/ssl/ca.pem --cluster-signing-key-file=/etc/kubernetes/ssl/ca-key.pem  --service-account-private-key-file=/etc/kubernetes/ssl/ca-key.pem --root-ca-file=/etc/kubernetes/ssl/ca.pem --leader-elect=true"
 
$ systemctl daemon-reload
$ systemctl enable kube-controller-manager
$ systemctl start kube-controller-manager

kube-scheduler

$ vi /etc/systemd/system/kube-scheduler.service
[Unit]
Description=Kubernetes Scheduler Plugin
Documentation=https://github.com/kubernetes/kubernetes
[Service]
EnvironmentFile=-/etc/kubernetes/config
EnvironmentFile=-/etc/kubernetes/scheduler
ExecStart=/usr/local/bin/kube-scheduler \
            $KUBE_LOGTOSTDERR \
            $KUBE_LOG_LEVEL \
            $KUBE_MASTER \
            $KUBE_SCHEDULER_ARGS
Restart=on-failure
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target
 
$ vi /etc/kubernetes/scheduler
###
# kubernetes scheduler config
# default config should be adequate
# Add your own!
KUBE_SCHEDULER_ARGS="--leader-elect=true --address=127.0.0.1"
 
$ systemctl daemon-reload
$ systemctl enable kube-scheduler
$ systemctl start kube-scheduler

Flannel

$ yum install -y flannel
$ vi /etc/systemd/system/flannel.service
[Unit]
Description=Flanneld overlay address etcd agent
After=network.target
After=network-online.target
Wants=network-online.target
After=etcd.service
Before=docker.service
[Service]
Type=notify
EnvironmentFile=/etc/flannel/flanneld
ExecStart=/usr/bin/flanneld-start \
  -etcd-endpoints=${ETCD_ENDPOINTS} \
  -etcd-prefix=${ETCD_PREFIX} \
  $FLANNEL_OPTIONS
ExecStartPost=/usr/libexec/flannel/mk-docker-opts.sh -i
Restart=on-failure
[Install]
WantedBy=multi-user.target
RequiredBy=docker.service
 
$ vi /etc/flannel/flanneld
# Flanneld configuration options 
# etcd url location.  Point this to the server where etcd runs
ETCD_ENDPOINTS="https://192.168.151.41:2379,https://192.168.151.40:2379,https://192.168.151.38:2379"
# etcd config key.  This is the configuration key that flannel queries
# For address range assignment
ETCD_PREFIX="/kube-flannel/network"
# Any additional options that you want to pass
FLANNEL_OPTIONS="-etcd-cafile=/etc/kubernetes/ssl/ca.pem -etcd-certfile=/etc/kubernetes/ssl/kubernetes.pem -etcd-keyfile=/etc/kubernetes/ssl/kubernetes-key.pem"
# docker.service 增加以下
EnvironmentFile=-/run/flannel/docker
EnvironmentFile=-/run/docker_opts.env
EnvironmentFile=-/run/flannel/subnet.env
 
# docker 配置cgroup为systemd
ExecStart=/usr/bin/dockerd -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock --api-cors-header='*' --exec-opt native.cgroupdriver=systemd
$ etcdctl \
  --ca-file=/etc/kubernetes/ssl/ca.pem \
  --cert-file=/etc/kubernetes/ssl/kubernetes.pem \
  --key-file=/etc/kubernetes/ssl/kubernetes-key.pem \
  mkdir /kube-flannel/network
etcdctl \
  --ca-file=/etc/kubernetes/ssl/ca.pem \
  --cert-file=/etc/kubernetes/ssl/kubernetes.pem \
  --key-file=/etc/kubernetes/ssl/kubernetes-key.pem \
  mk /kube-flannel/network/config '{"Network":"172.30.0.0/16","SubnetLen":24,"Backend":{"Type":"vxlan"}}'
 
$ systemctl daemon-reload
$ systemctl start flannel
$ systemctl status flannel
$ systemctl restart docker
$ etcdctl \
  --ca-file=/etc/kubernetes/ssl/ca.pem \
  --cert-file=/etc/kubernetes/ssl/kubernetes.pem \
  --key-file=/etc/kubernetes/ssl/kubernetes-key.pem \
  ls /kube-flannel/network/subnets

kubelet

$ vi /etc/systemd/system/kubelet.service
[Unit]
Description=Kubernetes Kubelet Server
Documentation=https://github.com/kubernetes/kubernetes
After=docker.service
Requires=docker.service
[Service]
WorkingDirectory=/var/lib/kubelet
EnvironmentFile=-/etc/kubernetes/config
EnvironmentFile=-/etc/kubernetes/kubelet
ExecStart=/usr/local/bin/kubelet \
            $KUBE_LOGTOSTDERR \
            $KUBE_LOG_LEVEL \
            $KUBELET_API_SERVER \
            $KUBELET_ADDRESS \
            $KUBELET_PORT \
            $KUBELET_HOSTNAME \
            $KUBE_ALLOW_PRIV \
            $KUBELET_POD_INFRA_CONTAINER \
            $KUBELET_ARGS
Restart=on-failure
[Install]
WantedBy=multi-user.target
 
$ vi /etc/kubernetes/kubelet
###
## kubernetes kubelet (minion) config
#
## The address for the info server to serve on (set to 0.0.0.0 or "" for all interfaces)
KUBELET_ADDRESS="--address=192.168.151.40"
#
## The port for the info server to serve on
KUBELET_PORT="--port=10250 --client-ca-file=/etc/kubernetes/ssl/ca.pem"
#
## You may leave this blank to use the actual hostname
KUBELET_HOSTNAME="--hostname-override=192.168.151.40"
#
## location of the api-server
#KUBELET_API_SERVER="--api-servers=https://192.168.151.41:6443"
#
## pod infrastructure container
KUBELET_POD_INFRA_CONTAINER="--pod-infra-container-image=gcr.io/google_containers/pause-amd64:3.0"
#
## Add your own!
KUBELET_ARGS="--allow-privileged=true --cgroup-driver=systemd --cluster-dns=10.1.0.2 --cluster-domain=cluster.local --cert-dir=/etc/kubernetes/ssl  --hairpin-mode promiscuous-bridge --serialize-image-pulls=false --kubeconfig=/etc/kubernetes/kubelet.kubeconfig --require-kubeconfig --cert-dir=/etc/kubernetes/ssl"
$ docker pull index.tenxcloud.com/google_containers/pause-amd64:3.0
$ docker tag index.tenxcloud.com/google_containers/pause-amd64:3.0 gcr.io/google_containers/pause-amd64:3.0
$ docker rmi index.tenxcloud.com/google_containers/pause-amd64:3.0
$ systemctl daemon-reload
$ systemctl enable kubelet
$ systemctl start kubelet
$ systemctl status kubelet

kube-proxy

$ vi /etc/systemd/system/kube-proxy.service
[Unit]
Description=Kubernetes Kube-Proxy Server
Documentation=https://github.com/kubernetes/kubernetes
After=network.target
[Service]
EnvironmentFile=-/etc/kubernetes/config
EnvironmentFile=-/etc/kubernetes/proxy
ExecStart=/usr/local/bin/kube-proxy \
        $KUBE_LOGTOSTDERR \
        $KUBE_LOG_LEVEL \
        $KUBE_MASTER \
        $KUBE_PROXY_ARGS
Restart=on-failure
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target
 
$ vi /etc/kubernetes/proxy
###
# kubernetes proxy config
# default config should be adequate
# Add your own!
KUBE_PROXY_ARGS="--bind-address=192.168.151.40 --hostname-override=192.168.151.40 --kubeconfig=/etc/kubernetes/kube-proxy.kubeconfig --cluster-cidr=10.1.0.0/16"
 
$ export KUBE_APISERVER="https://192.168.151.41:6443"
# 设置集群参数
$ kubectl config set-cluster kubernetes \
  --certificate-authority=/etc/kubernetes/ssl/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER}
# 设置客户端认证参数
$ kubectl config set-credentials proxy \
  --client-certificate=/etc/kubernetes/ssl/kube-proxy.pem \
  --embed-certs=true \
  --client-key=/etc/kubernetes/ssl/kube-proxy-key.pem
# 设置上下文参数
$ kubectl config set-context kube-proxy \
  --cluster=kubernetes \
  --user=proxy
# 设置默认上下文
$ kubectl config use-context kube-proxy
$ systemctl daemon-reload
$ systemctl enable kube-proxy
$ systemctl start kube-proxy
$ systemctl status kube-proxy

集群测试

$ kubectl run nginx --replicas=2 --labels="run=load-balancer-example" --image=nginx

2017年9月25日

利用区块链技术解决供应链信任问题
提案简述
通过CA证书机制增强供应链信任程度

利用区块链的不可篡改特性增加供应链透明度

私有交易机制维持商业谈判的机密程度

分布式拜占庭共识

高频交易，低延迟

新供应商自己发行证书

场景及数据描述

供应链充斥着假冒伪劣产品

高质量的供应商怎么证明其使用了高质量的零件

如果每一种原材料都使用基于区块链技术的CA机构背书会怎么样？

证书在供应链传递，直到最终商品

通过区块链进行零部件支付，以原子方式获取证书

任何人都可以验证商品零部件出处

市场上的新商品可以证明商品零部件的出处

技术挑战

高频交易需要可伸缩的数据结构（例如：RFID扫描所有收到的商品）

交易低延迟，高并发

竞争对手不能相信彼此数据的真实性，即便是使用区块链

零部件的生产必须由供应商背书

需要同样适用于所有的供应商，即便是新加入者

需要区块链支持私有交易：零部件的交易详情可以被买卖双方了解，但是不能让其他人看到

提案详情

使用简洁的数据结构表示一个批次的序列号集合，但是最终商品会被售卖给独立的消费者

恒星共识协议能够让供应商有能力防止CA证书的复制及滥用

基于区块链的支付与数字证书的所有权，交易很容易的和现实世界中的数据对接起来，比如RFID扫描

私有交易保护隐私，通过证明制造商买了某些零部件但是不公开价格信息，基于新的加密算法及零知识证明。

预期的产出及可交付成果

完整的区块链设计，包含以下三个组件：

可伸缩的数据结构

私有交易

快速的分布式拜占庭协议

原型实现论证可行性。
2017年9月25日

使用docker搭建kafka集群

IP	zookeeper	kafka
192.168.151.33	zookeeper.1(2181,2888,3888)	broker.1（9092，9093）
192.168.151.38	zookeeper.2(2181,2888,3888)	broker.2（9092，9093）
192.168.151.40	zookeeper.3(2181,2888,3888)	broker.3（9092，9093）
192.168.151.41		broker.4（9092，9093）

Docker镜像

# docker pull hyperledger/fabric-zookeeper
# docker pull hyperledger/fabric-kafka

docker-compose.yaml

version: '2'
services:
    zookeeper:
        image: hyperledger/fabric-zookeeper
        restart: always
        ports:
            - 2181:2181
            - 2888:2888
            - 3888:3888
        environment:
            ZOO_MY_ID: 1
            ZOO_SERVERS: server.1=0.0.0.0:2888:3888 server.2=192.168.151.38:2888:3888 server.3=192.168.151.40:2888:3888
 
    kafka:
        image: hyperledger/fabric-kafka
        restart: always
        ports:
            - 9092:9092
            - 9093:9093
        environment:
            KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
            KAFKA_UNCLEAN_LEADER_ELECTION_ENABLE: "false"
            KAFKA_DEFAULT_REPLICATION_FACTOR: 3
            KAFKA_MIN_INSYNC_REPLICAS: 2
            KAFKA_MESSAGE_MAX_BYTES: 1000000
            KAFKA_REPLICA_FETCH_MAX_BYTES: 1000000
            KAFKA_LOG_RETENTION_MS: -1
            KAFKA_ADVERTISED_HOST_NAME: "192.168.151.45"
            KAFKA_ADVERTISED_PORT: 9092
            KAFKA_ADVERTISED_LISTENERS: "PLAINTEXT://192.168.151.45:9092"
            KAFKA_BROKER_ID: 1

# docker-compose up -d

2017年9月25日

docker基础操作
docker基础命令

容器

创建一个新容器但不启动

1

docker create <image-id> 为镜像添加一个可读写层，构成一个容器（并未运行）。

参数

启动终止状态的容器

1

docker start <container-id> 为容器文件系统创建一个进程隔离空间（每个容器只能有一个进程隔离空间）。

参数

-i 附着到容器的标准输入

基于镜像新建一个容器并启动

1

docker run 等于是docker create和docker start两个命令的集合

操作流程
- 检查本地是否存在指定的镜像，不存在就从公有仓库下载
  
  利用镜像创建并启动一个容器
  
  分配一个文件系统，并在只读的镜像层外面挂载一层可读写层
  
  从宿主主机配置的网桥接口中桥接一个虚拟接口到容器中去
  
  从地址池配置一个 ip 地址给容器
  
  执行用户指定的应用程序
  
  执行完毕后容器被终止
参数

-i 让容器的标准输入保持打开

-t 分配一个伪终端并绑定到容器的标准输入上

-d 将容器在后台运行

停止容器

1

docker stop <container-id>    向运行中的容器发送一个SIGTERM信号，然后停止所有的进程

参数

-t 指定等待n秒后停止容器（默认为10）

1

docker kill <container-id>    向运行中的容器发送一个不友好的SIGKILL信号，然后停止所有的进程

参数

-s 发送指定信号到容器（默认为KILL）

删除容器

1

docker rm <container-id>    删除构成容器的可读写层

docker rm默认不会删除正在运行的容器

参数

-f 强制删除一个正在运行的容器（使用SIGKILL信号）

将容器转换为镜像

1

docker commit <container-id>    将容器的可读可写层转换成一个只读层，这样就把一个容器转换成了镜像

docker rm默认不会删除正在运行的容器

参数

-f 强制删除一个正在运行的容器（使用SIGKILL信号）

查看容器整体信息

1

docker ps

参数

-a 显示所有容器（默认只显示正运行的）

-q 只显示容器ID

-n n 只显示最近n个容器信息

-s 显示容器使用的磁盘空间

查看容器或镜像详细信息

1

docker instpect <container-id>或<image-id>

镜像

镜像命令

1

docker images 查看

参数

-a 显示所有镜像

-f 根据条件过滤要显示的镜像

-q 只显示镜像ID

删除镜像的只读层

1

docker rmi <image-id>    删除构成容器的一个或多个可读层（删除最顶层的唯一方法）

参数

-f 强制删除一个镜像

查看镜像的历史镜像

1

docker history <image-id>    递归地输出指定镜像的历史镜像
2017年9月25日
Docker安装部署
一、Docker介绍和与传统虚拟机的对比

二、查看系统和内核（要求可连接公网）

三、安装docker

四、docker镜像（image）

五、容器环境搭建配置

六、创建多个容器

七、日常使用和其他常用命令
一、Docker介绍和与传统虚拟机的对比

1、Docker与传统虚拟机对比

Docker所代表的容器虚拟化技术属于操作系统级虚拟化：内核通过创建多个虚拟的操作系统实例（内核和库）来隔离不同的进程。

传统虚拟化和容器技术结构比较：传统虚拟化技术是在硬件层面实现虚拟化，增加了系统调用链路的环节，有性能损耗；容器虚拟化技术以共享Kernel的方式实现，几乎没有性能损耗。

2、Docker结构引擎

Docker是Client/Server的架构
- Docker Server：就是一个守护进程（daemon），用户不能直接和守护进程打交道，但是可以通过Docker客户端与其进行交互。其中daemon负责构建、运行和发布Docker容器（客户端可以和服务端运行在同一个系统中，也可以连接远程的daemon）。
- Docker Client：客户书写指令的地方，一般就是shell
- RESTful API：Docker客户端通过RESTful API与daemon进行socket通信
- Image：俗称镜像
- Container：俗称容器，装载和运行镜像
- Network：俗称网络，容器通过暴露端口与主机端口绑定，达到接受来自主机的信号
- Volume：俗称外挂，为了能够持久化数据以及共享容器间的数据，Docker提出了Volume的概念
3、Docker运行流程

当我们想运行一个容器的时候，docker会做如下操作：
拉取镜像，若本地已经存在该镜像，则不用到网上去拉取

创建新的容器

分配union文件系统并且挂着一个可读写的层，任何修改容器的操作都会被记录在这个读写层上，你可以保存这些修改成新的镜像，也可以选择不保存，那么下次运行改镜像的时候所有修改操作都会被消除

分配网络\桥接接口，创建一个允许容器与本地主机通信的网络接口

设置ip地址，从池中寻找一个可用的ip地址附加到容器上，换句话说，localhost并不能访问到容器

运行你指定的程序

捕获并且提供应用输出，包括输入、输出、报错信息
二、查看系统和内核（要求可连接公网）

1、查看系统版本

cat /etc/issue

2、查看内核(内核版本最低要求2.6.32)

cat /proc/version

三、安装docker

1、yum源安装docker

yum install docker-io -y

2、查看安装版本

docker -v

3、更改镜像和容器指向路径

yum安装的docker默认是在根分区的，所以我们要修改镜像和容器路径指向数据盘。

创建用来存储镜像的路径

mkdir /export/docker

打开配置文件

vim /etc/sysconfig/docker

修改路径：other_args=”–graph=/export/docker”

4、启动docker服务

service docker start

四、docker镜像（image）

0、Docker镜像
- Docker 镜像，就相当于是一个文件系统。比如官方镜像 ubuntu:14.04 就包含了完整的一套 Ubuntu 14.04 最小系统的 root 文件系统。
- Docker 镜像是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数(如匿名卷、环境变量、用户等)。镜像不包含任何动态数据，其内容在构建之后也不会被改变。
1、查看centos镜像列表

docker search centos

2、获取镜像

获取镜像命令：docker pull [选项] [Docker Registry地址]<仓库名>:<标签>
- Docker Registry地址：地址的格式一般是 <域名/IP>[:端口号] 。默认地址是 Docker Hub。
- 仓库名：如之前所说，这里的仓库名是两段式名称。对于 Docker Hub，如果不给出用户名，则默认为 library，也就是官方镜像。
这里我们根据上面列出的centos的镜像，按照star的数量选第一个

docker pull centos:6.8

3、查看 / 删除已经获取的镜像

查看：docker images

删除：docker rmi

五、容器环境搭建配置

0、镜像(Image)和容器(Container)的关系，就像是面向对象程序设计中的类和实例一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。
- 容器的实质是进程，但与直接在宿主执行的进程不同，容器进程运行于属于自己的独立的命名空间。因此容器可以拥有自己的 root 文件系统、自己的网络配置、自己的进程空间，甚至自己的用户 ID 空间。容器内的进程是运行在一个隔离的环境里，使用起来，就好像是在一个独立于宿主的系统下操作一样。这种特性使得容器封装的应用比直接在宿主运行更加安全。
- 容器存储层的生存周期和容器一样，容器消亡时，容器存储层也随之消亡。因此，任何保存于容器存储层的信息都会随容器删除而丢失。
- 按照 Docker 最佳实践的要求，容器不应该向其存储层内写入任何数据，容器存储层要保持无状态化。所有的文件写入操作，都应该使用数据卷(Volume)、或者绑定宿主目录（我们为了方便，使用了绑定了宿主目录），在这些位置的读写会跳过容器存储层，直接对宿主(或网络存储)发生读写，其性能和稳定性更高，这样的容器可以随意删除、重新 run ，数据却不会丢失。
1、生成容器

docker run -it –name mupeifeng -v /export/mupeifeng/:/home/ centos:6.8 /bin/bash

-it 是以前台交互运行的方式

–name 指定容器名称

-v 指定该容器挂载宿主机的目录，我们这里是将宿主机的 /export/mupeifeng/ 挂载到容器的 / home /，这样宿主机和容器就可以很方便的传文件之类的。

2、部署环境（PHP7.1+MySql5.7+Nginx+Redis+ openssh）
- LNMP：为了方便部署我们使用的是整理好的LNMP源码包（先下载打包好的源码包到/home/目录下http://soft.vpser.net/lnmp/lnmp1.4-full.tar.gz，然后解压执行安装脚本，进行编译安装即可）。
- Openssh：安装 : yum install openssh-server -y
修改配置文件/etc/ssh/sshd_config中内容 :

PermitRootLogin yes

UsePAM no

修改root密码： passwd

启动sshd : service sshd start
- VIM无插件配置（可选）, yum -y install vim
  
  展开原码
⚠️ /home/目录下的东西在定镜像时不会保留。

3、定制镜像

查看所有容器信息，获取容器id：docker ps -a

commit生成新镜像：docker commit -m “备注” 容器id 镜像名:tag版本

查看镜像列表：docker images

4、其他定制镜像方法

Dockerfile

六、创建多个容器

需求：我们需要给每人创建一个容器，并且都要可以通过宿主机80端口访问容器的80端口（因为我们的宿主机对外开放的只有一个80端口）。

思路：
- 首先我们将宿主机的8080端口映射到容器的80端口，这样我们要想访问容器的80端口，只需要直接访问宿主机的8080端口即可。这样我们每添加一台容器，只要在宿主机添加一个到该容器80端口的映射端口就可以了。
- 然后我们在nginx里添加一个反向代理，将访问宿主机的80请求，转发到宿主机的8080，这样就完美解决了端口限制的问题。每添加一台容器就在宿主机添加添加一个nginx的反向代理就可以了。
1、首先建立宿主机和容器的端口映射

docker run -it –name mupeifeng -v /export/mupeifeng/:/home/ -p 8080:80 -p 8082:22 lnmp:7.1 /bin/bash

-p 就是把宿主机的端口和容器的端口进行绑定，我们这里是将宿主机的8082端口绑定到容器的22端口，这样我们就可以通过ssh root@127.0.0.1 -p 8082登陆到容器。

2、在宿主机通过nginx建立反向代理

为了方便管理，我们将每个人在宿主机的nginx配置目录下（/etc/nginx/conf.d）都单独建立了一个配置文件。

nginx具体配置内容如下：

展开原码

七、日常使用和其他常用命令

1、我们定制的Docker镜像是开启了sshd服务的，所以可以在宿主机通过绑定的端口进行ssh登陆，进行操作。

例如：我的容器22端口在宿主机绑定的是8082，那么我就可以在登陆宿主机（目前我们的宿主机是172.20.222.112）后通过ssh root@127.0.0.1 -p 8082登陆到容器。

ssh的初始用户是root，初始密码：1qaz@WSX

目前对应的端口列表如下：

或者我们也可以通过如下命令重新以前台交互的方式进入容器里

docker exec -it 容器id /bin/bash

另外：我们只需要在本地的hosts中配置172.20.222.112 test.自己名字拼音.com，就可以在浏览器通过访问test.自己名字拼音.com访问自己配置的项目（目前配置的项目目录是宿主机的/export/自己名字拼音/wwwroot/default/或者是登陆容器后的/home/wwwroot/default）。

2、其他常用的Docker命令

docker stop 容器id

终止一个正在运行的容器

docker start 容器id

启动已终止容器

启动ssh服务

docker exec -t -i <id/container_name> /bin/bash

service sshd start

docker logs -f -t –since=”2017-09-11″ –tail=10 mupeifeng

查看日志

–since : 此参数指定了输出日志开始日期，即只输出指定日期之后的日志。

-f : 查看实时日志

-t : 查看日志产生的日期

-tail=10 : 查看最后的10条日志。

mupeifeng : 容器名称
赞同2个人表示赞同
2017年9月25日
新申请docker容器，安装mysql

1）前提条件，配置阿里源
mv /etc/yum.repos.d/* /tmp/

wget http://dev.mysql.com/get/mysql57-community-release-el6-8.noarch.rpm
rpm -ivh mysql57-community-release-el6-8.noarch.rpm –nodeps –force
yum -y install yum-utils (安装yum-config-manager 命令) 如果执行这个命令报错，请将192.168.101.30 root/1qaz@WSX /etc/yum.repos.d/源拷贝到同目录（阿里源）
yum-config-manager –disable mysql57-community
yum-config-manager –enable mysql56-community
yum install mysql-community-server

service mysqld start
mysql -uroot -p (空密码，直接回车即可)
SET PASSWORD FOR ‘root’@’localhost’ = PASSWORD(‘root’);

mysql> show variables like ‘%character%’;
+————————–+—————————-+
| Variable_name | Value |
+————————–+—————————-+
| character_set_client | latin1 |
| character_set_connection | latin1 |
| character_set_database | latin1 |
| character_set_filesystem | binary |
| character_set_results | latin1 |
| character_set_server | latin1 |
| character_set_system | utf8 |
| character_sets_dir | /usr/share/mysql/charsets/ |
+————————–+—————————-+

set character_set_client = utf8;

set character_set_server = utf8;

set character_set_connection = utf8;

set character_set_database = utf8;

set character_set_results = utf8;

set collation_connection = utf8_general_ci;

set collation_database = utf8_general_ci;

set collation_server = utf8_general_ci;
create database app_relation character set utf8;

到此数据库安装完成。

2017年9月22日
RESTful API 设计
准备知识

HTTP的头域包括四个部分：

通用头：通用头部是客户端和服务器都可以使用的头部，可以在客户端、服务器和其他应用程序之间提供一些非常有用的通用功能，如Date头部

请求头：请求头部是请求报文特有的，它们为服务器提供了一些额外信息，例如客户端希望接收什么类型数据的Accept头部

响应头：响应头部便于客户端提供信息，例如表示客服端在与哪种类型的服务器进行交互的Server头部

实体头：实体头部指的是用于实体主体部分的头部，例如表示主体部分内容类型的Content-Type头部

设计RESTful API之前，必须了解的几个HTTP头信息：

Accept：请求头，表示发送端（客户端）希望接收的数据类型，比如： Accept: application/json, text/json

Content-Type：实体头，表示发送端（客户端或服务端）发送的实体数据类型，比如 Content-Type: text/html; charset=UTF-8

REST概念

略… …

设计准则

1 版本

API的版本在设计时应该强制性要求，这样未来更改API结构时，不会破坏旧版本的兼容。版本常用的设计方式有两种：

一种设计方式是版本号作为URL的一部分，例如： api.jd.com/uchance/v1/…

另一种方式比较巧妙，也是推荐的做法，使用Accept HTTP请求头传递版本信息，Github就是这么做的： Accept: application/vnd.github.v3+json

2 命名

在对资源命名时要使用名词，不要使用动词。HTTP提供的GET、POST、PUT、DELETE方法让你可以操作数据：

GET api.jd.com/uchance/products # 获取产品列表

POST api.jd.com/uchance/products # 添加产品

PUT api.jd.com/uchance/products/1 # 修改ID为1的产品

DELETE api.jd.com/uchance/products/1 # 删除ID为1的产品

3 单数还是复数

在资源命名时要使用名词的复数，不然单数、复数混合很快会变的混乱和不一致，即使POST、PUT、DELETE也应该使用复数。

4 嵌套资源

当我们想获取一个资源集合的子集合时，应该进行嵌套设计。例如我们要获取订单列表：

GET api.jd.com/uchance/products/1/orders # 以产品维度，获取产品编号为1的所有订单列表

GET api.jd.com/uchance/users/1/orders # 以用户维度，获取用户编号为1的所有订单列表

5 分页

当返回的数据量比较大时，我们需要分页，分页的做法一般是作为HTTP参数传递：

GET api.jd.com/uchance/products?page=1&limit=20 # 获取产品列表，页码为1，每页显示20条

6 状态码

返回内容（成功或失败）时，应当使用合适的HTTP状态码，GO专享因为微信端的历史原因，没有完全按照HTTP Status Codes规范。

下边是一些常用的HTTP状态码：

成功时的状态码
200：成功，表示服务器已经成功处理了请求
201：创建，表示服务器执行成功，并且创建了新的资源
202：已接受，表示服务器已经接受了请求，当请求排队等待进行后台处理时，应该使用它（异步任务）
204：空内容，应该在请求被正确执行，但没有返回任何内容时使用（例如当你删除某些东西）
… …

失败时的状态码
400：错误请求，当请求参数或内容有误时使用
401：无权限，当请求没有权限时使用
403：被进制，当请求成功（有权限401），但是操作被禁止（比如没有DELETE权限）
406：不接受，当请求的内容不被服务器接受时，例如服务器接受XML，但客户端提交的是JSON
410：结束，当请求的资源被永久删除时返回
422：验证错误，当创建对象时发生验证错误
… …

设计误区

下边是一些错误的设计示例：

GET api.jd.com/uchance/product # 使用单数的资源名称

GET api.jd.com/uchance/products/1?limit=20 # 分页参数不能作为资源

POST api.jd.com/uchance/products/create # 使用动词命名资源

设计实例

请求设计示例：

GET api.jd.com/uchance/products?page=1&limit=20&type=1 # 获取产品列表，过滤参数为page=1、limit=20、type=1

GET api.jd.com/uchance/products/1 # 获取编号为1的产品

GET api.jd.com/uchance/products/form # 获取产品新建页数据

POST api.jd.com/uchance/products # 新建产品（提交产品新建数据）

GET api.jd.com/uchance/products/1/form # 获取产品编号为1的修改页数据

PUT api.jd.com/uchance/products/1 # 修改产品编号为1的产品（提交产品修改数据）

DELETE api.jd.com/uchance/products/1 # 删除产品编号为1的产品

该文档参考了以下链接：

https://developer.github.com/guides/traversing-with-pagination/

https://developer.github.com/v3/media/#request-specific-version

https://bourgeois.me/
2017年9月22日
应用服务器jvm参数配置

web

IP地址：127.0.0.1
JVM参数配置：
export JAVA_OPTS=”-Djava.library.path=/usr/local/lib -server -Xms3072m -Xmx3072m -XX:MaxPermSize=256m -Djava.awt.headless=true -Dsun.net.client.defaultConnectTimeout=60000 -Dsun.net.client.defaultReadTimeout=60000 -Djmagick.systemclassloader=no -Dnetworkaddress.cache.ttl=300 -Dsun.net.inetaddr.ttl=300 -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=$CATALINA_BASE/logs -XX:ErrorFile=$CATALINA_BASE/logs/java_error_%p.log”

service

IP地址：127.0.0.1
JVM参数配置：
export JAVA_OPTS=”-Djava.library.path=/usr/local/lib -server -Xms3072m -Xmx3072m -XX:MaxPermSize=256m -Djava.awt.headless=true -Dsun.net.client.defaultConnectTimeout=60000 -Dsun.net.client.defaultReadTimeout=60000 -Djmagick.systemclassloader=no -Dnetworkaddress.cache.ttl=300 -Dsun.net.inetaddr.ttl=300 -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=$CATALINA_BASE/logs -XX:ErrorFile=$CATALINA_BASE/logs/java_error_%p.log”

2017年9月22日
mysql数据文件迁移

测试环境分配的虚拟机，安装mysql后，mysqll的数据文件默认在/var/lib/mysql下

但是根路径的磁盘大小是10G，不太够用，/export路径比较大，有40G空间，所以决定把数据文件迁移到/export下

1.关闭mysql服务

service mysqld stop

2.迁移数据文件

数据文件的位置可以从/etc/my.cnf中看到

迁移文件：mv /var/lib/mysql /export/servers/mysql

3.修改mysql配置文件

编辑/etc/my.cnf文件：修改[mysqld]下的datadir和socket，并指向新的路径

datadir=/export/servers/mysql
socket=/export/servers/mysql/mysql.sock

4.启动mysql服务

service mysqld start

参考文档：http://www.jb51.net/article/47897.htm

2017年9月22日