Linux: 阿里云使用

TAGS: Linux

kernel

https://gitlab.com/gitlab-org/charts/gitlab/

#cpu加速
echo "cpupower frequency-set -g performance" >> /etc/rc.local
echo "echo 1 > /proc/sys/net/ipv4/vs/ignore_no_rs_error" >> /etc/rc.loal
echo "echo 1 > /proc/vm/fast_slub_nr_free" >> /etc/rc.local
echo 1 > /proc/sys/vm/fast_slub_nr-free;
echo 1 > /proc/sys/net/ipv4/vs/ignore_no_rs_error

cpupower frequency-set -g performance

ECS

磁盘扩容

1. 扩容云盘（Linux系统）

参考：https://help.aliyun.com/document_detail/44986.html?spm=a2c4g.11174283.6.836.d94352fe9MVzl3

准备

# 镜像文件添加200G，不能有快照
qemu-img resize haproxy-clone.qcow2 +200G
qemu-img info haproxy-clone.qcow2

步骤一：创建快照

步骤三：查看云盘分区情况

#1. 远程登录ECS实例
#2. 运行命令fdisk -lu查看实例的云盘情况
[root@zentao01 ~]# fdisk -lu
Disk /dev/vda: 322.1 GB, 322122547200 bytes, 

   Device Boot      Start         End      Blocks   Id  System
/dev/vda1   *        2048   209715199   104856576   83  Linux

#System取值Linux表示为MBR分区。
#System取值GPT表示为GPT分区

#3. 运行命令blkid确认已有分区的文件系统类型。
[root@zentao01 ~]# blkid
/dev/vda1: UUID="7becd1b9-80e8-438c-9dd8-2985c6f5be36" TYPE="xfs"

步骤四：扩容分区

#1. 远程登录ECS实例。
#2. 安装gdisk工具
#如果您的分区为GPT格式，必须执行此步骤；如果您的分区为MBR格式，请跳过此步骤

yum install gdisk -y

#3. 运行命令growpart /dev/vda 1扩容分区
#安装growpart工具和resize2fs工具
yum install -y cloud-utils-growpart  
yum install -y xfsprogs
[root@zentao01 ~]# growpart /dev/vda 1
CHANGED: partition=1 start=2048 old: size=209713152 end=209715200 new: size=629143519 end=629145567

报错

[root@jenkins ~]# growpart /dev/vda 1
NOCHANGE: partition 1 could only be grown by -33 [fudge=2048]

解决：磁盘重新挂载或者重启虚拟机实例

步骤五：扩容文件系统

# 1. 远程登录ECS实例。
# 2. 根据查询的文件系统类型，扩容文件系统。
#扩容ext*（例如ext4）文件系统：运行命令resize2fs /dev/vda1扩容文件系统

#扩容系统盘/dev/vda1的文件系统
resize2fs /dev/vda1

#扩容数据盘/dev/vdb1的文件系统
e2fsck -f /dev/vdb1     //强制检查文件系统
resize2fs /dev/vdb1


# 扩容容xfs文件系统：运行命令xfs_growfs /media/vdc扩容文件系统。
#说明 /media/vdc为/dev/vdc1的挂载点，您需要根据实际情况修改。
xfs_growfs  /

#3. 运行命令df -Th检查扩容后结果
[root@zentao01 ~]# df -Th
Filesystem     Type      Size  Used Avail Use% Mounted on
/dev/vda1      xfs       300G  1.7G  299G   1% /
devtmpfs       devtmpfs  2.0G     0  2.0G   0% /dev

范例：linux ext4扩容，适合于云上实例、KVM

# 镜像文件添加200G，不能有快照
qemu-img resize haproxy-clone.qcow2 +200G
qemu-img info haproxy-clone.qcow2

yum install gdisk cloud-utils-growpart -y
fdisk -lu
growpart /dev/vdb 1
resize2fs  /dev/vdb1 # xfs执行 xfs_growfs  /dev/vdb
df -Th

2. 扩展分区和文件系统_Linux数据盘

参考:https://help.aliyun.com/document_detail/25452.html?spm=a2c4g.11186623.2.26.69d35bb8fAu3sA#section-gg7-ilv-h3j

AWS EC2 更换系统盘案例

主题：rummy 读域名修改指向及 rummy 215 磁盘更换系统扩容

背景：

rummy 一台 mysql 从库 172.21.89.215 根磁盘急需扩容 215 实例只有一个 2T 系统盘，系统盘做了 MBR 分区，使用率 94% MBR 引导盘容量上限 2 T ，无法应对后期数据增长。

需求：

rummy 读域名修改指向及 rummy 215 磁盘更换系统扩容

操作步骤：

1、rummy 读域名：db-reader.xxx.com

域名指向： 89.215 —> 89.84 对应的 NLB

旧：P1-a10b8a96e9eddfcd.elb.ap-south-1.amazonaws.com

新：Pa10b8a96e9eddfcd.elb.ap-south-1.amazonaws.com

2、172.21.89.215 数据目录扩容

准备系统盘：新 ec2

使用 AMI PFGC-DB-Common-Image 新建 ec2，系统盘200G XFS
关机，根卷分离，记录卷id vol-018401235208e553b
新 ec2 实例删除

更换系统盘：215 从库 ec2

关机, 根卷分离，记录卷id i-015fdd06360774689，实例id i-015fdd06360774689
附加卷，选择新卷 /dev/sda1
开机
附加卷，选择旧根卷 /dev/xvdf

挂载使用：mount -t xfs -o nouuid /dev/xvdf1 /data1

ps: 2个卷的uuid一样，修改/etc/fstab 使用设备名区分挂载
启动 mysql
后续：新增数据卷 NT，gpt分区挂载

准备数据盘：gp3 卷

创建 3T 卷，卷id vol-0c41d6db13107f3d0
附加卷到 215 机器上 /dev/sdg，此过程无需停机
初始化卷并挂载卷，初始化为 xfs 文件系统并挂载到 /data1

sudo mkfs -t xfs /dev/nvme2n1
添加 mysql 服务实例同步主库数据

操作：SRE, DBA

遇到的问题：

如果时区不对，修改时区为印度区

ln -sf /usr/share/zoneinfo/Asia/Calcutta /etc/localtime
date -R

挂载卷不显示

需要把这台服务器的 / 目录挂在到其他服务器上，再写密钥

在其他服务器上挂载，有时候 mount 挂载不上，需要加参数 -o nouuid

mount -t xfs -o nouuid /dev/xvdf1 /data1

关机会收到报警

Time: 2022-01-13 06:40:46
Alert:  Rummy mysql_slave  172.21.89.215:9104 is down
Value: 0.00s

Time: 2022-01-13 06:44:16
Alert: Rummy_nodes Rummy DB   172.21.89.215:9100  down for more than 2 minutes.
Value: 0.00

参考文档：

https://aws.amazon.com/cn/premiumsupport/knowledge-center/ec2-ubuntu-convert-mbr-to-gpt/

快照

优化成本：购买预付费存储包。

快照数据独立存储，存储费用可使用OSS标准（LRS）存储包抵扣。当您购买了OSS标准（LRS）存储包后，在有效期内，存储包会自动按容量抵扣快照费用。

系统救援

aws ec2

I executed yum -y update, disconnected in the middle, restarting the machine can't start

您可以从最近的备份中恢复，或者您需要进行故障排除和修复。从备份恢复更快更容易，但其他选项也可以工作

您为此实例拥有的帐户和唯一备份是从 2021 年 9 月 29 日开始的。我认为那太远了

救援模式

首先，请在 ap-south-1b 可用区启动一个救援实例，使用 Amazon Linux 2 的 t2.micro 类型。注意网络、安全组保持一致。
停止损坏的实例并分离根卷。然后挂载会救援实例上。
在救援实例执行如下操作

# 确认坏卷已附加到救援实例
10:50:20 AM jasper.xu: [root@ip-172-21-38-206 data]# lsblk
NAME    MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
xvda    202:0    0    8G  0 disk
└─xvda1 202:1    0    8G  0 part /
xvdf    202:80   0  100G  0 disk
└─xvdf1 202:81   0  100G  0 part /data

# 挂载
mkdir /mnt/old
mount -t xfs -o nouuid /dev/xvdf1 /mnt/old
cat /mnt/old/etc/fstab
11:32:16 AM jasper.xu: UUID=eaadd3f0-e151-4950-a4ba-49ae6f413224 /                       xfs     defaults        0 0

# 在救援实例根目录中
cd /
for i in dev proc sys run; do mount -o bind /$i /mnt/old/$i; done
chroot /mnt/old   #uname -r 将反映救援实例中的内核
grub2-mkconfig -o /boot/grub2/grub.cfg
sed -i 's/GRUB_DEFAULT=0/GRUB_DEFAULT=saved/g' /etc/default/grub
[root@ip-172-21-38-206 /]# sudo grub2-mkconfig -o /boot/grub2/grub.cfg
Generating grub configuration file ...
Found linux image: /boot/vmlinuz-3.10.0-1160.53.1.el7.x86_64
Found linux image: /boot/vmlinuz-3.10.0-862.14.4.el7.x86_64
Found initrd image: /boot/initramfs-3.10.0-862.14.4.el7.x86_64.img
Found linux image: /boot/vmlinuz-3.10.0-862.2.3.el7.x86_64
Found initrd image: /boot/initramfs-3.10.0-862.2.3.el7.x86_64.img
Found linux image: /boot/vmlinuz-0-rescue-5b3e73494c0f9aac8764a045f4a3a8f5
Found initrd image: /boot/initramfs-0-rescue-5b3e73494c0f9aac8764a045f4a3a8f5.img

grub2-set-default 1

# 卸载卷
for i in dev proc sys run; do sudo umount /mnt/old/$i; done

请立即从救援实例中分离此卷，附加到您的旧实例并启动实例

start succesful kernel 3.10.0-862.14.4.el7.x86_64

升级内核

sudo rpm --import https://www.elrepo.org/RPM-GPG-KEY-elrepo.org 
rpm -Uvh https://www.elrepo.org/elrepo-release-7.0-3.el7.elrepo.noarch.rpm 
yum list available --disablerepo='*' --enablerepo=elrepo-kernel
elrepo-release.noarch                                                                                 7.0-5.el7.elrepo                                                                         elrepo-kernel
kernel-lt.x86_64                                                                                      5.4.181-1.el7.elrepo                                                                     elrepo-kernel

sudo yum --enablerepo=elrepo-kernel install kernel-lt
# 首先查看当前系统有几个内核。比如：
cat /boot/grub2/grub.cfg |grep menuentry 
# 设置默认的启动内核
grub2-set-default "CentOS Linux (5.4.181-1.el7.elrepo.x86_64) 7 (Core)"
# 验证是否修改成功
grub2-editenv list
# 重启机器观察
reboot

SLB

实例类型对应监控指标

SLB：最大连接数（秒）每秒新建连接数（CPS）每秒查询数（QPS）

监控：每秒最大并发连接数每秒新建连接数

七层才有QPS的概念，指的是每秒可以完成的HTTP/HTTPS的查询（请求）的数量。当请求速率超过规格所定义的每秒查询数时，新建连接请求将被丢弃。对应监控见截图：

1.最大并发连接数对应SLB实例规则中最大连接数,活跃连接数指established状态的连接，非活跃连接指除了established状态的连接。

2.七层才有QPS的概念，指的是每秒可以完成的HTTP/HTTPS的查询（请求）的数量。当请求速率超过规格所定义的每秒查询数时，新建连接请求将被丢弃。对应监控见截图

3.对于4层监听端口，上限指标只有最大连接数每秒新建连接数（CPS)

咱们slb是4层的4w多是第秒最大连接数既最大并发数，Qps是每秒查询数属于7层协议

网络互通

公司与阿里新加坡互通 vpn-ipsec

参考教程：https://help.aliyun.com/document_detail/65279.html?spm=a2c4g.11186623.6.552.3c94466aIf33LR

创建VPN网关：新加的VPC公网VPN
创建用户网关：公司本地网关的信息
创建IPsec连接：VPN网关和用户网关建立连接后的VPN通道。

{
  "LocalSubnet": "10.0.0.0/14",
  "RemoteSubnet": "10.18.0.0/16",
  "IpsecConfig": {
    "IpsecPfs": "group1",
    "IpsecEncAlg": "des",
    "IpsecAuthAlg": "sha1",
    "IpsecLifetime": 86400
  },
  "Local": "211.103.135.97",
  "Remote": "161.117.252.191",
  "IkeConfig": {
    "IkeAuthAlg": "sha1",
    "LocalId": "211.103.135.97",
    "IkeEncAlg": "des",
    "IkeVersion": "ikev1",
    "IkeMode": "main",
    "IkeLifetime": 86400,
    "RemoteId": "161.117.252.191",
    "Psk": "123456",
    "IkePfs": "group1"
  }
}

配置本地网关：本地VPN网关设备中加载阿里云VPN网关的配置。公司由IT中心人员在路由H3C上设置
配置VPN网关路由：在VPN网关中配置策略路由表，并发布到VPC路由表中。源阿里新加坡VPC10.18.0.0/16，目标网段公司10.0.0.0/14

测试访问

登录到阿里云VPC内一台无公网IP的ECS实例，通过ping本地IDC内一台服务器的私网IP地址，验证通信是否正常。

阿里新加坡机房VPC与阿里华北2机房VPC网络互通-高速通道

开通云企业云
将2个机房机的vpc加入到云企业网
购买跨境带宽包。注意这个需要向阿里提交企业审查。
跨地域互通带宽管理。选择华北与新加坡互通带宽。
配置互通网段

需要在新加坡侧入地域网关，先做允许北京vpc实例，只允许精确匹配10.16.205.0/24；然后再做拒绝北京vpc实例，模糊匹配vpc的大网段10.16.0.0/16。如果不同vpc应该你源实例ID表再加需要模糊拒绝的vpc实例。

阿里新加坡机房VPC与阿里华北2机房VPC网络互通-vpn-ipsec临时方案

分别在新加坡与华北2机房创建vpn-ipsec，注意这里的用户网关是对端的网关地址，即新加坡用户网关配置为华北2 SNAT出口ip，华北2用户网关配置为新加坡 SNAT出口ip，

阿里云vpc与亚马逊vpc互通-vpn

阿里云

创建VPN网关：新加坡VPC公网VPN

47.94.150.81

亚马逊

创建客户网关：ip为阿里云vpn网关ip

47.94.150.81

创建私有网关：创建好后与vpc绑定
创建站点到站点VPN连接：

VPN连接中的配置

1.路由选项中使用静态IP前缀，这里填写要互通的阿里VPC网段

其它默认即可

2.创建好后可在Tunnel State看到外面ip地址，选项其中一个做为阿里云的用户网关

这里13.250.188.18

3.在VPN连接页面上点击“下载配置”，获取双方一致的通信认证配置

ike proposal 200
  encryption-algorithm aes-cbc
  authentication-method pre-share
  dh group2
  sa duration 28800
  authentication-algorithm sha
quit

...
ike peer peervpn1
  remote-address 13.250.188.18
  pre-shared-key jAlnufeIfGG6nK5FWODmLfdAy2Omqdtr
  exchange-mode main
  proposal 200
  dpd dpdvpn1
quit

...
psec transform-set ipsec-prop-vpn1 
  encapsulation-mode tunnel
  esp encryption-algorithm aes-cbc-128
  esp authentication-algorithm sha1
quit
....
ipsec profile ipsecvpn1
  ike-peer peervpn1		
  pfs dh-group2
  sa duration time-based 3600
  transform-set ipsec-prop-vpn1
quit

阿里云

创建用户网关：亚马逊网关的信息

13.250.188.18

创建IPsec连接：VPN网关和用户网关建立连接后的VPN通道。

{
  "LocalSubnet": "0.0.0.0/0",
  "RemoteSubnet": "0.0.0.0/0",
  "IpsecConfig": {
    "IpsecPfs": "group2",
    "IpsecEncAlg": "aes",
    "IpsecAuthAlg": "sha1",
    "IpsecLifetime": 3600
  },
  "Local": "13.250.188.18",
  "Remote": "47.94.150.81",
  "IkeConfig": {
    "IkeAuthAlg": "sha1",
    "LocalId": "13.250.188.18",
    "IkeEncAlg": "aes",
    "IkeVersion": "ikev1",
    "IkeMode": "main",
    "IkeLifetime": 28800,
    "RemoteId": "47.94.150.81",
    "Psk": "jAlnufeIfGG6nK5FWODmLfdAy2Omqdtr",
    "IkePfs": "group2"
  }
}

配置VPN网关路由：在VPN网关中配置目标路由，并发布到VPC路由表中。

目标路由：亚马逊网段

OSS

如何选用NAS、OSS和EBS

本文介绍阿里云文件存储NAS与阿里云对象存储OSS、阿里云块存储EBS的区别，帮助您更好地选用阿里云文件存储NAS。

文件存储NAS提供简单、可伸缩弹性的共享文件存储，配合云服务器ECS弹性计算服务构建业务系统。当您选择使用文件存储NAS、对象存储OSS或块存储EBS部署应用程序时，需要考虑诸多因素。本文介绍文件存储NAS与对象存储OSS、块存储EBS的区别，帮助您更好地进行选择。

文件存储NAS和对象存储OSS有什么不同？

文件存储NAS和对象存储OSS的主要区别：您无需修改应用，即可直接像访问本地文件系统一样访问文件存储NAS。文件存储NAS提供高吞吐和高IOPS的同时支持文件的随机读写和在线修改。

对象存储OSS是比较新的存储类型，相对于文件存储目录树的组织形式，对象存储OSS采用扁平的文件组织形式，采用RESTFul API接口访问，不支持文件随机读写，主要适用于互联网架构的海量数据的上传下载和分发。

文件存储NAS和块存储EBS有什么不同？

文件存储NAS相对于块存储EBS的主要区别：文件存储NAS可以同时支持上千个ECS客户端同时共享访问，提供高吞吐量。

块存储EBS是裸磁盘，挂载到ECS后不能被操作系统应用直接访问，需要格式化成文件系统（ext3、ext4、NTFS等）后才能被访问。块存储EBS的优势是性能高、时延低，适合于OLTP数据库、NoSQL数据库等IO密集型的高性能、低时延应用工作负载。但是块存储EBS无法容量弹性扩展，单盘最大只能32TB，并且对共享访问的支持有限，需要配合类Oracle RAC、WSFC Windows故障转移集群等集群管理软件才能进行共享访问。因此，块存储EBS主要还是针对单ECS的高性能，低时延的存储产品。

存储产品	时延	吞吐	访问模式
文件存储NAS	低时延（毫秒级）	数百Gbps	上千个ECS通过POSIX接口并发访问，随机读写
对象存储OSS	较低时延（几十毫秒级）	数百Gbps	数百万客户端通过WEB并发，追加写
块存储EBS	极低时延（微秒级）	数十Gbps	单ECS通过POSIX接口访问，随机读写

解冻转换文件类型

#  cat oss_changefile.sh 
#!/bin/env bash
#1、解冻资源 
./ossutil64 restore oss://cici-result-video/ -r  -f
sleep 300
#2、更新set-meta值，这个是更新无论是归档还是低频，都转换成标准
./ossutil64 set-meta oss://cici-result-video/ -r X-Oss-Storage-Class:Standard --update  -j 5000 --retry-times 3 --loglevel=debug

ossfs文件挂载

参考： https://help.aliyun.com/document_detail/32196.html?spm=5176.product31815.6.1041.uGNIMY

#下载安装包
wget http://gosspublic.alicdn.com/ossfs/ossfs_1.80.6_centos7.0_x86_64.rpm
yum localinstall ossfs_1.80.6_centos7.0_x86_64.rpm  -y

#配置账号访问信息
cat <<\EOF> /etc/passwd-ossfs 
cici-log-backup:LTxx5G:iJsmWZxxSvgz
EOF
chmod 640 /etc/passwd-ossfs


#将Bucket挂载到指定目录
mkdir /OSS
/usr/local/bin/ossfs cici-log-backup /OSS -ourl=oss-cn-beijing-internal.aliyuncs.com -o allow_other -oumask=002

df -h

echo '/usr/local/bin/ossfs cici-log-backup /OSS -ourl=oss-cn-beijing-internal.aliyuncs.com -o allow_other -oumask=002'  >> /etc/rc.local

#挂载此 bucket:
fusermount -u /tmp/ossfs

OSS 访问授权

只对名为 hdzy 的oss存储中zone/answer/ 和 book_photo_path/ 目录有上传读权限，没有删除权限

注意前后顺序

{
  "Version": "1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "oss:ListBuckets",
        "oss:GetBucketAcl"
      ],
      "Resource": [
        "acs:oss:*:*:*"
      ]
    },
    {
      "Effect": "Allow",
      "Action": [
        "oss:Get*",
    "oss:Put*",
      ],
      "Resource": [
        "acs:oss:*:*:hdzy/zone/answer/*"
      ]
    },
    {
      "Effect": "Allow",
      "Action": [
        "oss:ListObjects"
      ],
      "Resource": [
        "acs:oss:*:*:hdzy"
      ],
      "Condition": {
        "oss:Delimiter":"/",
        "StringLike": {
          "oss:Prefix": [
            "",
            "zone/",
            "zone/answer/*"
          ]
        }
      }
    }
  ]
}

OSS 访问控制

1.授权 RAM 用户完全管理某个 Bucket: myphotos 的权限。

{
    "Version": "1",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "oss:*",
            "Resource": [
                "acs:oss:*:*:myphotos",
                "acs:oss:*:*:myphotos/*"
            ]
        }
    ]
}


2：授权 RAM 用户列出并读取一个 Bucket 中的资源。
{
    "Version": "1",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": ["oss:ListObjects","oss:GetObject"],
            "Resource": [
                "acs:oss:*:*:myphotos",
                "acs:oss:*:*:myphotos/*"
                ]
        }
    ]
}

某公司

{
    "Version": "1",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "oss:ListParts",
                "oss:AbortMultipartUpload",
                "oss:PutObject",
                "oss:GetObject",
                "oss:listObjects",
                "oss:GetBucketReferer",
                "oss:SetBucketReferer",
                "oss:DeleteBucket",
                "oss:CreateBucket",
                "oss:GetBucketAcl"
            ],
            "Resource": [
                "acs:oss:*:*:xjp-cici-app",
                "acs:oss:*:*:xjp-cici-app/*"
            ]
        }
    ]
}

1.只访问和编写bucket ： mfs-source 中的单个目录

在RAM中配置权限策略

{
  "Version": "1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "oss:ListBuckets"
      ],
      "Resource": [
        "acs:oss:*:*:*"
      ]
    },
    {
      "Effect": "Allow",
      "Action": [
        "oss:ListObjects"
      ],
      "Resource": [
        "acs:oss:*:*:mfs-source"
      ],
      "Condition": {
        "StringLike": {
          "oss:Delimiter": "/",
          "oss:Prefix": [
            "",
            "BackendEditor/*"
          ]
        }
      }
    },
    {
      "Effect": "Allow",
      "Action": [
        "oss:ListObjects"
      ],
      "Resource": [
        "acs:oss:*:*:mfs-source"
      ],
      "Condition": {
        "StringLike": {
          "oss:Prefix": [
            "BackendEditor/*"
          ]
        }
      }
    },
    {
      "Effect": "Allow",
      "Action": [
        "oss:*"
      ],
      "Resource": [
        "acs:oss:*:*:mfs-source/BackendEditor/*"
      ]
    }
  ]
}

2.bukect上传查看权限

{
  "Version": "1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "oss:ListBuckets",
        "oss:GetBucketAcl"
      ],
      "Resource": [
        "acs:oss:*:*:mfs-source",
        "acs:oss:*:*:mfs-source/*"
      ]
    },
    {
      "Effect": "Allow",
      "Action": [
        "oss:Get*",
        "oss:Put*"
      ],
      "Resource": [
        "acs:oss:*:*:mfs-source",
        "acs:oss:*:*:mfs-source/*"
      ]
    }
  ]
}

3.数据库审计权限

{
  "Statement": [
    {
      "Action": "rds:DescribeSQLLogRecords",
      "Effect": "Allow",
      "Resource": "acs:rds:*:*:dbinstance/rdsjmlwvi81yzyaypa1gb"
    },
    {
      "Action": "rds:DescribeSQLLogRecords",
      "Effect": "Allow",
      "Resource": "*"
    }
  ],
  "Version": "1"
}

4.数据库权限

{
  "Version": "1",
  "Statement": [
    {
      "Action": "rds:*",
      "Resource": "acs:rds:*:*:*",
      "Effect": "Allow"
    },
    {
      "Action": "dms:LoginDatabase",
      "Resource": "acs:rds:*:*:dbinstance/rm-bp1o4v71t63p433f2",
      "Effect": "Allow"
    }
  ]
}

nodejs +OSS STS

nodejs安装

wget https://nodejs.org/dist/v6.10.0/node-v6.10.0-linux-x64.tar.xz
tar xvf node-v6.10.0-linux-x64.tar.xz
ln -sv node-v6.10.0-linux-x64 node

cat >/etc/profile.d/node.sh<<\EOF
export NODE_HOME=/usr/local/node
export PATH=$PATH:$NODE_HOME/bin
export NODE_PATH=$NODE_HOME/lib/node_modules
EOF
source /etc/profile
node  -v

#设置 淘宝镜像源
npm config set registry https://registry.npm.taobao.org

#查看 使用的 镜像源
npm config get registry

#安装 淘宝镜像源
npm install -g cnpm --registry=https://registry.npm.taobao.org

A simple app server using STS

App Server一般作为一个企业的应用服务器，它管理着OSS的 AccessKeyId/AccessKeySecret，服务于众多的客户端。当客户端（移动端 /Web/Client等）需要访问OSS时，它们向App Server请求一个临时的token，并利用这个token从OSS下载或者向OSS上传文件。

App Server可以实现更复杂的策略，为不同的客户端提供不同权限的token，隔离不同的客户端的存储路径等。

使用参考：https://help.aliyun.com/document_detail/oss/practice/ram_guide_dir/no_user_accout.html

Run

#Checkout code
git clone https://github.com/rockuw/node-sts-app-server.git
cd node-sts-app-server

#Install dependencies
npm install

#Start server
node index.js

#Open in your browser
http://localhost:3000/


vim config.json
{
  "AccessKeyId" : "Lxxx",
  "AccessKeySecret" : "IJ8N4S",
  "RoleArn" : "acs:ram::1253088:role/aliyunosstokengeneratorrole",
  "TokenExpireTime" : "900",
  "PolicyFile": "policy/all_policy.txt"
}

云服务器 ECS Nodejs 通过forever 设置后台运行及 Nodejs 链接 MySQL RDS

Nodejs 应用通过 forever 设置后台运行

默认可以通过 node app.js 启动 nodejs 应用，如果退出 ssh 连接，应用也会退出。

可以使用 Forever 来管理启动 nodejs 应用，Forever 可以看做是一个 nodejs 的守护进程，能够启动，停止，重启我们的 app 应用

如同官方的描述

A simple CLI tool for ensuring that a given script runs continuously (i.e. forever).// 一个用来持续（或者说永远）运行一个给定脚本的简单的命令行工具

安装
sudo npm install forever -g #记得加-g，forever要求安装到全局环境下

启动
forever start app.js
forever start -o out.log -e err.log app.js     #-o 是 console 输出的日志，-e 是 console.error 日志
forever list ##显示所有运行的服务

开机自启动可以添加到 /etc/rc.local 里

常见的参数配置

-m MAX: 运行指定脚本的次数
-l LOGFILE: 输出日志到LOGFILE
-o OUTFILE: 输出控制台信息到OUTFILE
-e ERRFILE: 输出控制台错误在ERRFILE
-p PATH: 根目录
-c COMMAND: 执行命令，默认是node
-a, –append: 合并日志
-f, –fifo: 流式日志输出
-n, –number: 日志打印行数
–pidFile: pid文件
–sourceDir: 源代码目录
–minUptime: 最小spinn更新时间(ms)
–spinSleepTime: 两次spin间隔时间
–colors: 控制台输出着色
–plain: –no-colors的别名，控制台输出无色
-d, –debug: debug模式
-v, –verbose: 打印详细输出
-s, –silent: 不打印日志和错误信息
-w, –watch: 监控文件改变
–watchDirectory: 监控顶级目录
–watchIgnore: 通过模式匹配忽略监控
--workingDir     The working directory in which SCRIPT will execute
-h, –help: 命令行帮助信息

3种守护进程使用场合不完全一样。

supervisor 是开发环境用。

forever 管理多个站点，每个站访问量不大，不需要监控。

pm2 网站访问量比较大，需要完整的监控界面。

启动脚本

[root@web04-hd-13083 ~]# cat /etc/init.d/node
#!/bin/bash
### BEGIN INIT INFO
# Provides:       
# Required-Start:   $all
# Required-Stop:     $all
# Default-Start:     2 3 4 5
# Default-Stop:   0 1 6
# Short-Description: Start daemon at boot time
# Description:     Enable service provided by daemon.
### END INIT INFO
# chkconfig: 345 88 08
# description: Forever for Node.js

DEAMON=/usr/local/node-sts-app-server/index.js   #这里需要填写你自己的Node项目的启动脚本文件
LOG=/usr/local/node-sts-app-server/log/node.log  #可选，日志文件目录
PID=/usr/local/node-sts-app-server/pid  #必填内容，用于记录forever的进程号
WORKDIR=/usr/local/node-sts-app-server
USER=operator1
#export PATH=$PATH:/usr/local/bin  #在这里指定一下Node的可执行程序安装目录，我的是/usr/local/bin
#export NODE_PATH=$NODE_PATH:/usr/local/node-sts-app-server/node_modules  #这里是Node类库的路径

#往下的内容就不用修改了

node=node
forever=forever

case "$1" in
    start)
       /bin/su -l operator1 -c  "$forever start -l $LOG -a --workingDir=$WORKDIR  --pidFile $PID  $DEAMON"
        ;;
    stop)
        $forever stop --pidFile $PID $DEAMON
        ;;
    stopall)
        $forever stopall --pidFile $PID
        ;;
    restartall)
        $forever restartall --pidFile $PID
        ;;
    reload|restart)
        /bin/su -l operator1 -c  "$forever restart -l $LOG --pidFile $PID -a --workingDir=$WORKDIR  $DEAMON"
        ;;
    list)
        $forever list
        ;;
    *)
        echo "Usage: /etc.init.d/node {start|stop|restart|reload|stopall|restartall|list}"
        exit 1
        ;;
esac

#访问权限
chown -R operator1.operator1 node-sts-app-server/

oss跨域

https://help.aliyun.com/document_detail/31870.html?spm=5176.11065259.1996646101.searchclickresult.1d762eadmmqkJN

* Access-Control-Allow-Origin 指定允许的跨域请求的来源。 *
  说明 您可以填写*表示全部域名；也可以填写完整域名，例如www.aliyun.com。
* Access-Control-Allow-Headers  指定允许的跨域请求的字段。 X-Custom-Header
* Access-Control-Allow-Methods  指定允许的跨域请求方法。  POST、GET
  说明 如果您需要同时添加POST和GET，请使用英文逗号（,）隔开。
* Access-Control-Max-Age  指定客户端程序对特定资源的预取请求返回结果的缓存时间。 600
* Access-Control-Expose-Headers 指定允许访问的自定义头信息。  Content-Length

*
GET,POST,PUT,DELETE,HEAD
*
ETag
x-oss-request-id

使用 curl 测试存储桶 CORS 配置是否正确：

curl -I -v -L -H 'origin: <跨域请求的来源域名>' <s3资源地址>

如果响应头中有如下请求头，则表示配置正确：

Access-Control-Allow-Origin: <curl 请求时 -H 参数指定的值>
Access-Control-Allow-Methods: <s3 存储桶 CORS 配置指定的请求方法>

腾讯-COS

#跨域*

cdn添加跨域配置后，如果还有跨域的问题，可能就是对应的cos桶没有添加跨域配置

搜索框搜索桶名，点击进入详情页面，在安全管理中选择跨域访问COES设置，添加配置

aws-s3

参考：https://docs.aws.amazon.com/zh_cn/AmazonS3/latest/userguide/enabling-cors-examples.html

s3 –> 权限 –> 跨源资源共享(CORS)

[
    {
        "AllowedHeaders": [
            "*"
        ],
        "AllowedMethods": [
            "GET"
        ],
        "AllowedOrigins": [
            "https://*.cici.com"
        ],
        "ExposeHeaders": []
    }
]

NAS

创建NAS创建挂载点

#安装NFS客户端
yum install -y nfs-utils
# 提高同时发起的NFS请求数量
sudo echo "options sunrpc tcp_slot_table_entries=128" >>  /etc/modprobe.d/sunrpc.conf 
sudo echo "options sunrpc tcp_max_slot_table_entries=128" >>  /etc/modprobe.d/sunrpc.conf

#挂载NFS文件系统
编辑：/etc/fstab
1b3d14be74-dux60.cn-beijing.nas.aliyuncs.com:/172.18.30.140  /iyunwen/resource/    nfs4   vers=4.0,minorversion=0,rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2,_netdev,noresvport 0 0

mount -a

#注意172.18.30.140目录提前创建好
# mount -t nfs -o vers=4,minorversion=0,rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2,noresvport 1b3d14be74-dux60.cn-beijing.nas.aliyuncs.com:/  /home/suoper/share
# cd /home/suoper/share/
# mkdir 172.18.30.140
# umount /home/suoper/share

短信服务

调用SendSms发送短信

模版名称：数据系统操作通知

模版CODE：SMS_190282220

模板内容：`${userName}账号在 ${time} 进行了"${operateType}"操作，涉及到数据行数（${rawNumber}），请关注`。

---------–—代码样例

#!/usr/bin/env python
#coding=utf-8

from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.request import CommonRequest
client = AcsClient('<accessKeyId>', '<accessSecret>', 'cn-hangzhou')

request = CommonRequest()
request.set_accept_format('json')
request.set_domain('dysmsapi.aliyuncs.com')
request.set_method('POST')
request.set_protocol_type('https') # https | http
request.set_version('2017-05-25')
request.set_action_name('SendSms')

request.add_query_param('RegionId', "cn-hangzhou")
request.add_query_param('PhoneNumbers', "135224xx")
request.add_query_param('SignName', "xcw")
request.add_query_param('TemplateCode', "SMS_190282220")
request.add_query_param('TemplateParam', "{\"userName\":\"xuchangwei\",\"time\":\"2020-05-16 15:01:00\",\"operateType\":\"数据系统\",\"rawNumber\":\"1000\"}")

response = client.do_action(request)
# python2:  print(response) 
print(str(response, encoding = 'utf-8'))

调用SendBatchSms接口批量发送短信

API调用访问认证：

AcxxxsKey ID: LTA

accxxxsSecret: ah5P

签名：xcw

模版CODE：SMS_190282079

模板内容：`通知：${name}正在进行升级维护，商品${payContent}，您暂时无法进行${payType}，预计${time}之前恢复`。

import com.aliyuncs.CommonRequest;
import com.aliyuncs.CommonResponse;
import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.exceptions.ClientException;
import com.aliyuncs.exceptions.ServerException;
import com.aliyuncs.http.MethodType;
import com.aliyuncs.profile.DefaultProfile;
/*
pom.xml
<dependency>
  <groupId>com.aliyun</groupId>
  <artifactId>aliyun-java-sdk-core</artifactId>
  <version>4.5.0</version>
</dependency>
*/
public class SendBatchSms {
    public static void main(String[] args) {
        DefaultProfile profile = DefaultProfile.getProfile("cn-hangzhou", "<accxxssKeyId>", "<accxxsSecret>");
        IAcsClient client = new DefaultAcsClient(profile);

        CommonRequest request = new CommonRequest();
        request.setSysMethod(MethodType.POST);
        request.setSysDomain("dysmsapi.aliyuncs.com");
        request.setSysVersion("2017-05-25");
        request.setSysAction("SendBatchSms");
        request.putQueryParameter("RegionId", "cn-hangzhou");
        request.putQueryParameter("PhoneNumberJson", "[\"13522xx\",\"1871026xx\"]");
        request.putQueryParameter("SignNameJson", "[\"xcw\",\"xcw\"]");
        request.putQueryParameter("TemplateCode", "SMS_190282079");
        request.putQueryParameter("TemplateParamJson", "[{\"name\":\"银行系统\",\"payContent\":\"暂停支付业务\",\"payType\":\"付款\",\"time\":\"2020-05-14\"},{\"name\":\"银行系统\",\"payContent\":\"暂停支付业务\",\"payType\":\"付款\",\"time\":\"2020-05-14\"}]");
        try {
            CommonResponse response = client.getCommonResponse(request);
            System.out.println(response.getData());
        } catch (ServerException e) {
            e.printStackTrace();
        } catch (ClientException e) {
            e.printStackTrace();
        }
    }
}

CDN

服务管理

刷新预热

CDN提供的资源的刷新和预热功能的概念如下：

刷新功能是指提交URL刷新或目录刷新请求后，CDN节点的缓存内容将会被强制过期，当您向CDN节点请求资源时，CDN会直接回源站获取对应的资源返回给您，并将其缓存。刷新功能会降低缓存命中率。
预热功能是指提交URL预热请求后，源站将会主动将对应的资源缓存到CDN节点，当您首次请求时，就能直接从CDN节点缓存中获取到最新的请求资源，无需再回源站获取。预热功能会提高缓存命中率。

注意： 如果修改了源文件需要先执行url刷新先清除缓存配置，再操作url预热

手动刷新

操作

登录[CDN控制台](https://cdn.console.aliyun.com/)。
在左侧导航栏，单击 刷新预热 。
在 刷新缓存 页签，您可以根据所需，配置刷新或预热信息

OSS开始域名自动刷新

自动刷新脚本

RAM访问策略

{
    "Version": "1",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "cdn:PushObjectCache",
                "cdn:RefreshObjectCaches"
            ],
            "Resource": "acs:cdn:*:*:*",
            "Condition": {
                "IpAddress": {
                    "acs:SourceIp": [
                        "211.103.135.96/29",
                        "172.28.30.56",
                        "123.57.87.183"
                    ]
                }
            }
        }
    ]
}

https://help.aliyun.com/document_detail/151829.html?spm=5176.10695662.1996646101.searchclickresult.5aea25a1CxcObd

# 依赖
pip install aliyun-python-sdk-core
pip install aliyun-python-sdk-cdn

# 脚本
cat <<\EOF > /data/ops/Refresh.py 
#!/usr/bin/env python
#coding=utf-8
# __author__ = 'hanli.zyb'

'''Check Package'''

try:
 import os, sys, getopt, time, json
 from aliyunsdkcore.client import AcsClient
 from aliyunsdkcore.acs_exception.exceptions import ClientException
 from aliyunsdkcore.acs_exception.exceptions import ServerException
 from aliyunsdkcdn.request.v20180510.RefreshObjectCachesRequest import RefreshObjectCachesRequest
 from aliyunsdkcdn.request.v20180510.PushObjectCacheRequest import PushObjectCacheRequest
 from aliyunsdkcdn.request.v20180510.DescribeRefreshTasksRequest import DescribeRefreshTasksRequest
 from aliyunsdkcdn.request.v20180510.DescribeRefreshQuotaRequest import DescribeRefreshQuotaRequest
except:
 sys.exit("[Error] Please pip install aliyun-python-sdk-cdn and aliyun-java-sdk-core ，please install now......")

reload(sys)
sys.setdefaultencoding('utf8')

class Refresh(object):

  '''init func'''

  def __init__(self):

   self.lists = []
   self.param = {}

  '''
  描述：调度的主函数
  resP：检测入参结果，如果类型不是 bool 说明有报错
  '''

  def main(self,argv):
    if len(argv) < 1 :
      sys.exit("\nusage: " + sys.argv[0] + " -h ")
    try:
      opts,args = getopt.getopt(argv,"hi:k:n:r:t:a:o:")
    except Exception as e :
      sys.exit("\nusage: " + sys.argv[0] + " -h ")

    for opt,arg in opts:
      if opt == '-h':
        self.helps()
        sys.exit()
      elif opt == '-i':
        self.param['-i'] = arg
      elif opt == '-k':
        self.param['-k'] = arg
      elif opt == '-r':
        self.param['-r'] = arg
      elif opt == '-t':
        self.param['-t'] = arg
      elif opt == '-a':
        self.param['-a'] = arg 
      elif opt == '-o':
        self.param['-o'] = arg
      elif opt == '-n':
        self.param['-n'] = arg
      else:
        sys.exit("\nusage: " + sys.argv[0] + " -h ")

    resP = self.doCheck(self.param)
    if not isinstance(resP,bool): sys.exit(resP)

    try:
      #client = AcsClient(self.param['-i'], self.param['-k'], 'cn-hangzhou')
      client = AcsClient('LTAI4xxfeqRNNitV', 'YpmiExxFnaCrlZ', 'cn-hangzhou')
    except NameError:
      sys.exit("[Error]: SDK module not detected")

    for g in self.doProd(self.param):
      self.lists = []
      self.doRefresh(''.join(g),self.param['-t'],client)

  '''
  描述：检测入参数
  '''
  def doCheck(self,param):

    try:
      #for key1 in ('-i','-k','-r','-t'):
      for key1 in ('-r','-t'):
        if not key1 in param.keys():
          return "[Error]: {0} Must be by parameter".format(key1)

      try:
        if not param.has_key('-n'):
          self.param['-n'] = 50
        if not (abs(int(param['-n'])) <= 100 and abs(int(param['-n'])) > 0):
          return "[Error]: 0 < -n <= 100"
        else:
          self.param['-n'] = int(param['-n'])
      except ValueError as e:
        return "[Error]: -n Must be int Type ,{0}".format(str(e))

      if not param['-t'] in ("push","clear"): return "[Error]: taskType Error"
      if param.has_key('-a') and param.has_key('-o'): return "[Error]: -a and -o cannot exist at same time"

      if param.has_key('-a'):
          if not param['-a'] in ("domestic","overseas"): 
            return "[Error]: Area value Error"
          if param['-t'] == 'clear':
            return "[Error]: -t must be push and 'clear' -o use together"

      if param.has_key('-o'):
          if not param['-o'] in ("File","Directory"):
            return "[Error]: ObjectType value Error"
          if param['-t'] == 'push':
            return "[Error]: -t must be clear and 'push' -a use together"

    except KeyError as e:
       return "[Error]: Parameter {0} error".format(str(e))
    return True

  '''
  描述：生成器切分文件，对每行文件进行处理 '\n'
  gop：每次读取 URL 数量
  '''
  def doProd(self,params):
    gop = params['-n']
    mins = 1
    maxs = gop

    #with open(params['-r'], "r") as f:
    #  for line in f.readlines():
    #    if mins != maxs:
    #     line = line.strip("\n") + "\n"
    #    else:
    #     line = line.strip("\n")
    #    self.lists.append(line)
    #    if mins >= maxs:
    #     yield self.lists
    #     mins = maxs
    #     maxs = gop + maxs -1
    #    else:
    #     mins += 1
    #  print self.lists
    #  if len(self.lists) > 0: yield self.lists
    self.lists.append(params['-r'])
    if len(self.lists) > 0: yield self.lists


  '''
  描述：刷新/预热任务
  '''
  def doRefresh(self,lists,types,client):
    try:
      if types == 'clear':
        taskID = 'RefreshTaskId'
        request = RefreshObjectCachesRequest()
        if self.param.has_key('-o'):
          request.set_ObjectType(self.param['-o'])
      elif types == 'push':
        taskID = 'PushTaskId'
        request = PushObjectCacheRequest()
        if self.param.has_key('-a'):
          request.set_Area(self.param['-a'])

      taskreq = DescribeRefreshTasksRequest()
      request.set_accept_format('json')
      request.set_ObjectPath(lists)
      response = json.loads(client.do_action_with_exception(request))
      print(response)

      while True:
        count = 0
        taskreq.set_accept_format('json')
        print(response[taskID].split(","))
        for id in response[taskID].split(","):
            #taskreq.set_TaskId(int(response[taskID]))
            taskreq.set_TaskId(int(id))
            taskresp = json.loads(client.do_action_with_exception(taskreq))
            #print("[" + response[taskID] + "]" + "is doing... ...")
            print("[" + id + "]" + "URL刷新中... ...")
            for t in taskresp['Tasks']['CDNTask']:
              if t['Status'] != 'Complete':
                count += 1
            time.sleep(5)
        if count == 0:
          break
        else:
          continue
    except Exception as e:
      sys.exit("[Error]" + str(e))

  '''
  描述：帮助信息
  '''
  def helps(self):
    print("\nscript options explain: \
            \n\t -i <AcxxssKey>                  访问阿里云凭证，访问控制台上可以获得； \
            \n\t -k <AccxxKeySecret>            访问阿里云密钥，访问控制台上可以获得； \
            \n\t -r <filename>                   文件名称，每行一条 URL，有特殊字符先做 URLencode，以 http/https 开头； \
            \n\t -t <taskType>                   任务类型 clear 刷新，push 预热； \
            \n\t -n [int,[..100]]                可选项，每次操作文件数量，做多 100 条； \
            \n\t -a [String,<domestic|overseas>  可选项，预热范围，不传是默认是全球；\
            \n\t    domestic                     仅中国大陆； \
            \n\t    overseas                     全球（不包含中国大陆）； \
            \n\t -o [String,<File|Directory>]    可选项，刷新的类型； \
            \n\t    File                         文件刷新（默认值）； \
            \n\t    Directory                    目录刷新")
#TODO 入口

if __name__ == '__main__':
  fun = Refresh()
  fun.main(sys.argv[1:])

EOF

# 执行
# python /data/ops/Refresh.py -r https://new-teacher.cici.com/ -t clear 
{u'RefreshTaskId': u'10542101638', u'RequestId': u'DFC3A1FC-C896-4B4B-8B79-0C81886A249C'}
[u'10542101638']
[10542101638]is doing... ...
[u'10542101638']
[10542101638]is doing... ...

```

cnd常用配置

缓存配置

bmp,jpg,png,tif,gif,pcx,tga,exif,fpx,svg,psd,cdr,pcd,dxf,ufo,eps,ai,raw,WMF,webp,mp4,wav

回源

回源-开启阿里云OSS私有Bucket回源

回源-过滤参数

https://help.aliyun.com/document_detail/27128.html?spm=5176.11065259.1996646101.searchclickresult.41437200joImMZ

过滤参数包括过滤参数和忽略参数这两个功能。

* 保留过滤参数：保留指定参数，多个参数之间用英文逗号隔开，未指定的参数将不会被保留。
* 忽略参数：删除指定参数，多个参数之间用空格隔开，剩余参数将不会被忽略。

概念跨域

被访问的一端设置跨域。如前端页面加了cnd中的图片地址，那么被访问端cnd就要设置跨域

access-control-allow-origin: * 或者http://ts-game.cici.com
Access-Control-Allow-Methods: GET,POST,OPTIONS

跨域资源共享（Cross-Origin Resource Sharing，CORS）简称跨域访问，是HTML5提供的标准跨域解决方案，允许Web应用服务器进行跨域访问控制，使得跨域数据传输得以安全进行。

背景信息

跨域访问是浏览器出于安全考虑而设置的一个限制，即同源策略。当A、B两个网站属于不同域时，来自于A网站页面中的JavaScript代码访问B网站时，浏览器会拒绝该访问。

例如当运行在同一个浏览器上的不同来源，例如www.example.com和www.test.com请求同一跨域资源时，若www.example.com的请求先到达服务器，服务器将请求的资源带上Access-Control-Allow-Origin的Header，并返回给www.example.com的用户。此时www.test.com也发起了请求，浏览器会将缓存的上一次请求响应返回给用户，Header的内容和CORS的要求不匹配，导致www.test.com请求失败。

同源策略限制从一个源加载的文档或脚本与另一个源的资源进行交互的方式，是用于隔离潜在恶意文件的关键安全机制。同协议、同域名（或 IP）、以及同端口视为同一个域。两个页面的协议、域名和端口（若指定了端口）相同，则视为同源。如下表给出了相对http://www.aliyun.com/org/test.html%E7%9A%84%E5%90%8C%E6%BA%90%E6%A3%80%E6%B5%8B%E7%A4%BA%E4%BE%8B%EF%BC%9A

* Access-Control-Allow-Origin 指定允许的跨域请求的来源。 *
说明 您可以填写*表示全部域名；也可以填写完整域名，例如www.aliyun.com。
* Access-Control-Allow-Headers  指定允许的跨域请求的字段。 X-Custom-Header
* Access-Control-Allow-Methods  指定允许的跨域请求方法。  POST、GET
说明 如果您需要同时添加POST和GET，请使用英文逗号（,）隔开。
* Access-Control-Max-Age  指定客户端程序对特定资源的预取请求返回结果的缓存时间。 600
* Access-Control-Expose-Headers 指定允许访问的自定义头信息。  Content-Length

cdn

https://help.aliyun.com/document_detail/27137.html?spm=5176.11785003.0.dexternal.7b0b142f3ou3vv

登录CDN控制台–>在左侧导航栏，单击域名管理–>在域名管理页面，单击目标域名对应的管理

在指定域名的左侧导航栏，单击缓存配置 –> 单击缓存HTTP响应头 –> 在缓存HTTP响应头页签，单击添加。

Access-Control-Allow-Origin *
Access-Control-Allow-Methods GET,POST,PUT,DELETE,HEAD
#注意 “是否允许重复”选不重复

k8s跨域

nginx.ingress.kubernetes.io/cors-allow-credentials: "true"
nginx.ingress.kubernetes.io/cors-allow-headers: '*'
nginx.ingress.kubernetes.io/cors-allow-methods: PUT,GET,POST,OPTIONS
nginx.ingress.kubernetes.io/cors-allow-origin: http://test-admin.d.rrinner.cn   （ 指定域名）
nginx.ingress.kubernetes.io/enable-cors: "true"

oss

https://help.aliyun.com/document_detail/31870.html?spm=5176.11065259.1996646101.searchclickresult.1d762eadmmqkJN

*
GET,POST,PUT,DELETE,HEAD
*
ETag
x-oss-request-id

证书到期时间

https免费证书自动续签，在到期前4天自动续签

问题排查工具

1、访问异常时间点【必要】

2、具体访问异常的URL【必要】；

2、访问CDN的节点IP，您可以通过ping加速域名得到【用户客户端环境允许可提供】；

3、请提供下报障用户客户端的IP和DNS信息，客户端浏览器直接访问https://cdn.dns-detect.alicdn.com/https/doc.html 并截图即可【必要】；

4、用户客户端访问的报错信息和截图【必要】；

5、通过浏览器按F12开发者模式中的network标签页中查看到，包括request、response头信息，并且帮忙获取header头response头信息中“EagleId: 7d4cf79f16183882838401048e ”这个字段；via中vcache7.cn3181代表一组CDN缓存节点【用户客户端环境允许可提供】；

6、收集域名解析信息，浏览器访问并截图 http://dns.alidns.com/resolve?name= 请填写报障域名【用户客户端环境允许可提供】；

白屏问题是这样的，有两个思路，一个是用户侧没有访问到cdn节点上，如果没有的话，有可能是被劫持；另一个是如果访问到cdn节点上，访问到的是哪一个节点，我这边需要根据节点ip定位当时的监控是否有问题，是否需要调整调度覆盖。

CDN厂商响应检测

https://www.uptrends.com/

RAM

访问控制

RAM-OSS

只对名为 hdzy 的oss存储中zone/answer/ 和 book_photo_path/ 目录有上传读权限，没有删除权限

注意前后顺序

{
  "Version": "1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "oss:ListBuckets",
        "oss:GetBucketAcl"
      ],
      "Resource": [
        "acs:oss:*:*:*"
      ]
    },
    {
      "Effect": "Allow",
      "Action": [
        "oss:Get*",
    "oss:Put*",
      ],
      "Resource": [
        "acs:oss:*:*:hdzy/zone/answer/*"
      ]
    },
    {
      "Effect": "Allow",
      "Action": [
        "oss:ListObjects"
      ],
      "Resource": [
        "acs:oss:*:*:hdzy"
      ],
      "Condition": {
        "oss:Delimiter":"/",
        "StringLike": {
          "oss:Prefix": [
            "",
            "zone/",
            "zone/answer/*"
          ]
        }
      }
    }
  ]
}

OSS 访问控制

1.授权 RAM 用户完全管理某个 Bucket: myphotos 的权限。

{
    "Version": "1",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "oss:*",
            "Resource": [
                "acs:oss:*:*:myphotos",
                "acs:oss:*:*:myphotos/*"
            ]
        }
    ]
}

2.授权 RAM 用户列出并读取一个 Bucket 中的资源。

{
    "Version": "1",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": ["oss:ListObjects","oss:GetObject"],
            "Resource": [
                "acs:oss:*:*:myphotos",
                "acs:oss:*:*:myphotos/*"
                ]
        }
    ]
}

某公司

{
    "Version": "1",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "oss:ListParts",
                "oss:AbortMultipartUpload",
                "oss:PutObject",
                "oss:GetObject",
                "oss:listObjects",
                "oss:GetBucketReferer",
                "oss:SetBucketReferer",
                "oss:DeleteBucket",
                "oss:CreateBucket",
                "oss:GetBucketAcl"
            ],
            "Resource": [
                "acs:oss:*:*:xjp-tope365-app",
                "acs:oss:*:*:xjp-tope365-app/*"
            ]
        }
    ]
}

1.只访问和编写bucket ： mfs-source 中的单个目录在RAM中配置权限策略

{
  "Version": "1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "oss:ListBuckets"
      ],
      "Resource": [
        "acs:oss:*:*:*"
      ]
    },
    {
      "Effect": "Allow",
      "Action": [
        "oss:ListObjects"
      ],
      "Resource": [
        "acs:oss:*:*:mfs-source"
      ],
      "Condition": {
        "StringLike": {
          "oss:Delimiter": "/",
          "oss:Prefix": [
            "",
            "BackendEditor/*"
          ]
        }
      }
    },
    {
      "Effect": "Allow",
      "Action": [
        "oss:ListObjects"
      ],
      "Resource": [
        "acs:oss:*:*:mfs-source"
      ],
      "Condition": {
        "StringLike": {
          "oss:Prefix": [
            "BackendEditor/*"
          ]
        }
      }
    },
    {
      "Effect": "Allow",
      "Action": [
        "oss:*"
      ],
      "Resource": [
        "acs:oss:*:*:mfs-source/BackendEditor/*"
      ]
    }
  ]
}

2.bukect上传查看权限

{
  "Version": "1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "oss:ListBuckets",
        "oss:GetBucketAcl"
      ],
      "Resource": [
        "acs:oss:*:*:mfs-source",
        "acs:oss:*:*:mfs-source/*"
      ]
    },
    {
      "Effect": "Allow",
      "Action": [
        "oss:Get*",
        "oss:Put*"
      ],
      "Resource": [
        "acs:oss:*:*:mfs-source",
        "acs:oss:*:*:mfs-source/*"
      ]
    }
  ]
}

RAM-RDS

数据库审计权限

{
  "Statement": [
    {
      "Action": "rds:DescribeSQLLogRecords",
      "Effect": "Allow",
      "Resource": "acs:rds:*:*:dbinstance/rdsjmlwvi81yzyaypa1gb"
    },
    {
      "Action": "rds:DescribeSQLLogRecords",
      "Effect": "Allow",
      "Resource": "*"
    }
  ],
  "Version": "1"
}

数据库权限

{
  "Version": "1",
  "Statement": [
    {
      "Action": "rds:*",
      "Resource": "acs:rds:*:*:*",
      "Effect": "Allow"
    },
    {
      "Action": "dms:LoginDatabase",
      "Resource": "acs:rds:*:*:dbinstance/rm-bp1o4v71t63p433f2",
      "Effect": "Allow"
    }
  ]
}

RDS单实例授权

RDS单实例授权(标签方式)

https://help.aliyun.com/document_detail/95252.html?spm=5176.11065259.1996646101.searchclickresult.ce1b473f50Zjxi

```bash

{
  "Statement": [
    {
      "Action": "rds:*",
      "Effect": "Allow",
      "Resource": "*",
      "Condition": {
        "StringEquals": {
          "rds:ResourceTag/k": "haibao"
        }
      }
    },
    {
      "Action": "rds:DescribeTag*",
      "Effect": "Allow",
      "Resource": "*"
    },
    {
      "Action": "dms:LoginDatabase",
      "Resource": "acs:rds:*:*:dbinstance/rm-rm-hp31i9h07g1ay3r7s",
      "Effect": "Allow"
    }
  ],
  "Version": "1"
}

以下能看到所有的RDS，但只能操作自己权限的RDS

https://help.aliyun.com/knowledge_detail/58932.html?spm=a2c4g.11186623.6.708.5b0966edJGHwuv

说明授予该策略的RAM用户是可以列出所有的RDS实例，但只能操作（比如DeleteDBInstance操作）其中的两台。目前，不支持RAM用户仅仅查看自己有访问权限的RDS实例。

RAM访问控制中设置组管理员

RAM权限概述:https://help.aliyun.com/document_detail/102666.html?spm=a2c4g.11186623.6.730.67e736a9bjc2CK

{
    "Version": "1",
    "Statement": [
        {
            "Action": [
                "ram:Get*",
                "ram:List*",
                "ram:GenerateCredentialReport"
            ],
            "Resource": "*",
            "Effect": "Allow"
        },
        {
            "Action": [
                "ram:AddUserToGroup",
                "ram:RemoveUserFromGroup",
                "ram:ListUsersForGroup",
                "ram:UpdateGroup",
                "ram:ListGroupsForUser"
            ],
            "Resource": [
                "acs:ram:*:*:group/sa-test",
                "acs:ram:*:*:user/*"
            ],
            "Effect": "Allow"
        }
    ]
}

注意：user后加*，表示要加哪些人到组内。

权限记录

Aliyun-denyDeleteAccess

{
    "Version": "1",
    "Statement": [
        {
            "Effect": "Deny",
            "Action": [
                "ecs:Delete*",
                "ecs:ModifyInstanceAutoReleaseTime",
                "slb:DeleteLoadBalancer",
                "vpc:DeleteVpc",
                "vpc:DeleteVSwitch",
                "vpc:DeleteRouteEntry",
                "vpc:DeleteRouteTable",
                "vpc:ReleaseEipAddress",
                "vpc:DeletePhysicalConnection",
                "vpc:DeleteRouterInterface",
                "vpc:DeleteVirtualBorderRouter",
                "vpc:DeleteBgpGroup",
                "vpc:DeleteBgpPeer",
                "vpc:DeleteNatGateway",
                "vpc:RemoveBandwidthPackageIps",
                "vpc:DeleteBandwidthPackage",
                "vpc:DeleteVpnGateway",
                "vpc:DeleteCustomerGateway",
                "vpc:DeleteVpnConnection",
                "rds:DeleteDBInstance",
                "rds:DeleteDatabase",
                "kvstore:DeleteInstance",
                "oss:DeleteBucket",
                "oss:DeleteBucketEncryption",
                "oss:DeleteObject",
                "oss:DeleteMultipleObjects",
                "cdn:DeleteCdnDomain",
                "ram:CreateAccessKey",
                "ram:DeleteAccessKey",
                "ram:DeleteVirtualMFADevice",
                "ram:DeleteUser",
                "ram:DeleteGroup",
                "ram:DeleteRole",
                "ram:DeletePolicy",
                "ram:CreatePolicyVersion",
                "ram:DeletePolicyVersion",
                "ram:SetDefaultPolicyVersion"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Deny",
            "Action": [
                "ram:AttachPolicyToUser",
                "ram:AttachPolicyToGroup",
                "ram:AttachPolicyToRole"
            ],
            "Resource": [
                "acs:ram:*:*:*"
            ]
        },
        {
            "Effect": "Deny",
            "Action": [
                "ram:DetachPolicyFromUser",
                "ram:DetachPolicyFromGroup",
                "ram:DetachPolicyFromRole"
            ],
            "Resource": [
                "acs:ram:*:*:*"
            ]
        }
    ]
}

组权限中。只要full权限在，deny就失效了

aliyunRAM-SAadmin

{
    "Version": "1",
    "Statement": [
        {
            "Action": [
                "ram:Create*",
                "ram:Get*",
                "ram:List*",
                "ram:GenerateCredentialReport"
            ],
            "Resource": "*",
            "Effect": "Allow"
        },
        {
            "Action": [
                "ram:AddUserToGroup",
                "ram:RemoveUserFromGroup",
                "ram:ListUsersForGroup",
                "ram:UpdateGroup",
                "ram:ListGroupsForUser"
            ],
            "Resource": [
                "acs:ram:*:*:group/*",
                "acs:ram:*:*:user/*"
            ],
            "Effect": "Allow"
        },
        {
            "Action": [
                "ram:AddUserToGroup",
                "ram:RemoveUserFromGroup",
                "ram:ListUsersForGroup",
                "ram:UpdateGroup",
                "ram:ListGroupsForUser"
            ],
            "Resource": [
                "acs:ram:*:*:group/dba"
            ],
            "Effect": "Deny"
        }
    ]
}

RAM-CDN

范例：刷新cdn，白名单ip有操作权限

{
    "Version": "1",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "cdn:PushObjectCache",
                "cdn:RefreshObjectCaches"
            ],
            "Resource": "acs:cdn:*:*:*",
            "Condition": {
                "IpAddress": {
                    "acs:SourceIp": [
                        "211.103.135.96/29",
                        "123.57.87.183",
                        "47.241.25.157",
                        "39.107.102.36"
                    ]
                }
            }
        }
    ]
}

RAM-STS

临时授权

1.ram中创建sts接口调用账号

2.创建自定义授权策略

创建权限策略oss-access

{
    "Version": "1",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "oss:ListParts",
                "oss:AbortMultipartUpload",
                "oss:PutObject",
                "oss:GetObject",
                "oss:listObjects",
                "oss:GetBucketReferer",
                "oss:SetBucketReferer",
                "oss:GetBucketAcl"
            ],
            "Resource": [
                "acs:oss:*:*:dev-operation-activity",
                "acs:oss:*:*:dev-operation-activity/*"
            ]
        }
    ]
}

3.创建RAM角色并关联权限策略

创建RAM角色abc-sts添加权限oss-access，记住ARN信息。

4.账号授权

添加sts调用权限和oss-access权限

5.接口调用

调用时使用ARN信息