1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

# 1. 安装 AWS CLI v2（推荐）
# Linux x86_64
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip && sudo ./aws/install

# macOS
brew install awscli

# 说明：老教程里的 pip install awscli 装的是 **v1**，目前只做少量维护，
# 新环境请用上面的 v2 安装方式；v2 自带打包的 Python，不受系统 Python 版本影响
aws --version

# 2. 配置凭证
# ⚠️ 不要用 root 账号的密钥。正确做法是创建 IAM 用户（并开启 MFA），
# 或更好：在 EC2/EKS 上用 IAM 角色，让程序完全不需要密钥
aws configure
# AWS Access Key ID: 你的 IAM 用户密钥
# AWS Secret Access Key: 你的 IAM 用户私钥
# Default region: us-east-1
# Default output format: json

# 也可以为不同环境配置多个 profile（生产/测试分开），避免误操作
aws configure --profile prod

# 3. 创建密钥对
aws ec2 create-key-pair \
    --key-name my-key \
    --query 'KeyMaterial' \
    --output text > ~/.ssh/my-key.pem

chmod 400 ~/.ssh/my-key.pem
# 注意：私钥只在创建时返回一次，丢了只能重新创建密钥对

# 4. 创建安全组
aws ec2 create-security-group \
    --group-name my-sg \
    --description "My security group" \
    --vpc-id vpc-xxxxxxxxx

# 5. 添加安全组规则
# ⚠️ 把 22 端口开放给 0.0.0.0/0 意味着全世界都能尝试暴力破解你的 SSH，
# 强烈建议改成你自己的出口 IP（如 203.0.113.5/32），或只允许通过跳板机访问
aws ec2 authorize-security-group-ingress \
    --group-id sg-xxxxxxxxx \
    --protocol tcp \
    --port 22 \
    --cidr 203.0.113.5/32

aws ec2 authorize-security-group-ingress \
    --group-id sg-xxxxxxxxx \
    --protocol tcp \
    --port 80 \
    --cidr 0.0.0.0/0

# 6. 查询"当前区域最新的 Amazon Linux 2023 AMI"
# AMI ID 是"每个区域一份"的，网上抄来的 ami-xxx 往往在你的区域根本不存在，
# 用 SSM 公共参数动态查询才是可靠做法
AMI_ID=$(aws ssm get-parameter \
    --name /aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-x86_64 \
    --query 'Parameter.Value' --output text)
echo "$AMI_ID"

# 7. 创建实例
aws ec2 run-instances \
    --image-id "$AMI_ID" \
    --instance-type t3.micro \
    --key-name my-key \
    --security-group-ids sg-xxxxxxxxx \
    --subnet-id subnet-xxxxxxxxx \
    --count 1 \
    --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=my-first-ec2}]'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# Linux/Mac，默认用户名取决于所用镜像：
# Amazon Linux / RHEL / CentOS 系 → ec2-user
ssh -i ~/.ssh/my-key.pem ec2-user@你的公网IP

# Ubuntu → ubuntu
ssh -i ~/.ssh/my-key.pem ubuntu@你的公网IP

# Debian → admin
ssh -i ~/.ssh/my-key.pem admin@你的公网IP

# Windows 实例用远程桌面（RDP），不是 SSH：
# 1) 先用私钥解密管理员密码（在本地执行，会返回明文密码）
aws ec2 get-password-data \
    --instance-id i-xxxxxxxxx \
    --priv-launch-key ~/.ssh/my-key.pem \
    --query 'PasswordData' --output text

# 2) 用返回的密码，通过 mstsc（远程桌面）连接 公网IP:3389

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# 查看实例
aws ec2 describe-instances

# 启动实例
aws ec2 start-instances --instance-ids i-xxxxxxxxx

# 停止实例
aws ec2 stop-instances --instance-ids i-xxxxxxxxx

# 重启实例
aws ec2 reboot-instances --instance-ids i-xxxxxxxxx

# 终止实例
aws ec2 terminate-instances --instance-ids i-xxxxxxxxx

# 创建 AMI
aws ec2 create-image \
    --instance-id i-xxxxxxxxx \
    --name "my-image-$(date +%Y%m%d)" \
    --description "My custom AMI"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 在实例内部访问元数据服务（169.254.169.254 是链路本地地址，从公网不可达）
# 获取实例 ID
curl http://169.254.169.254/latest/meta-data/instance-id

# 获取实例类型
curl http://169.254.169.254/latest/meta-data/instance-type

# 获取公网 IP
curl http://169.254.169.254/latest/meta-data/public-ipv4

# 获取本地区域
curl http://169.254.169.254/latest/meta-data/availability-zone

# 获取 IAM 角色（如果配置了）
curl http://169.254.169.254/latest/meta-data/iam/info

# 获取用户数据（启动脚本）
curl http://169.254.169.254/latest/user-data/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 分配弹性 IP（VPC 里的 EIP 要指定 --domain vpc）
aws ec2 allocate-address --domain vpc

# 关联到实例
aws ec2 associate-address \
    --instance-id i-xxxxxxxxx \
    --allocation-id eipalloc-xxxxxxxxx

# 解除关联（--association-id 可从 describe-addresses 查到）
aws ec2 disassociate-address \
    --association-id eipassoc-xxxxxxxxx

# 释放弹性 IP
# ⚠️ 计费提醒：AWS 自 2024 年 2 月起对"所有公网 IPv4 地址"收费
# （不管是否挂载在实例上，每小时约 $0.005），所以不用的 EIP 一定要释放
aws ec2 release-address \
    --allocation-id eipalloc-xxxxxxxxx

# 查看当前账号下有哪些 EIP 及其关联情况
aws ec2 describe-addresses \
    --query 'Addresses[].{IP:PublicIp,Instance:InstanceId,Alloc:AllocationId}' \
    --output table

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 创建应用负载均衡器
aws elbv2 create-load-balancer \
    --name my-alb \
    --subnets subnet-xxxx subnet-yyyy \
    --security-groups sg-xxxx

# 创建目标组
aws elbv2 create-target-group \
    --name my-targets \
    --protocol HTTP \
    --port 80 \
    --vpc-id vpc-xxxx

# 注册目标
aws elbv2 register-targets \
    --target-group-arn arn:aws:elasticloadbalancing:... \
    --targets Id=i-xxxx

# 创建监听器
aws elbv2 create-listener \
    --load-balancer-arn arn:aws:... \
    --protocol HTTP \
    --port 80 \
    --default-actions Type=forward,TargetGroupArn=arn:aws:...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 1. 创建 Bucket
aws s3 mb s3://my-unique-bucket-name

# 2. 上传文件
aws s3 cp myfile.txt s3://my-bucket/

# 3. 上传整个目录
aws s3 cp ./my-folder s3://my-bucket/my-folder/ --recursive

# 4. 下载文件
aws s3 cp s3://my-bucket/myfile.txt ./

# 5. 列出文件
aws s3 ls s3://my-bucket/

# 6. 同步目录（增量上传）
aws s3 sync ./my-folder s3://my-bucket/my-folder/

# 7. 删除文件
aws s3 rm s3://my-bucket/myfile.txt

# 8. 删除整个 Bucket（先清空）
aws s3 rb s3://my-bucket --force

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 1. 设置公有读（不推荐！）
aws s3api put-bucket-acl \
    --bucket my-bucket \
    --acl public-read

# 2. 设置 Bucket Policy
aws s3api put-bucket-policy \
    --bucket my-bucket \
    --policy file://policy.json

# policy.json 内容
cat > policy.json << 'EOF'
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": "*",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::my-bucket/*"
    }
  ]
}
EOF

# 3. 使用预签名 URL（临时访问）
aws s3 presign s3://my-bucket/private-file.txt --expires-in 3600

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# 创建生命周期规则
aws s3api put-bucket-lifecycle-configuration \
    --bucket my-bucket \
    --lifecycle-configuration file://lifecycle.json

# lifecycle.json
cat > lifecycle.json << 'EOF'
{
  "Rules": [
    {
      "ID": "Move to Glacier after 30 days",
      "Status": "Enabled",
      "Filter": {
        "Prefix": "logs/"
      },
      "Transitions": [
        {
          "Days": 30,
          "StorageClass": "GLACIER"
        },
        {
          "Days": 365,
          "StorageClass": "DEEP_ARCHIVE"
        }
      ]
    }
  ]
}
EOF

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 创建 CloudFront 分配
aws cloudfront create-distribution \
    --origin-domain-name my-bucket.s3.amazonaws.com

# 查看分配
aws cloudfront list-distributions

# 创建失效（清除缓存）
aws cloudfront create-invalidation \
    --distribution-id EXXXX \
    --paths "/*"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# 1. 创建 VPC
aws ec2 create-vpc \
    --cidr-block 10.0.0.0/16 \
    --tag-specifications 'ResourceType=vpc,Tags=[{Key=Name,Value=my-vpc}]'

# 2. 创建子网
aws ec2 create-subnet \
    --vpc-id vpc-xxxx \
    --cidr-block 10.0.1.0/24 \
    --availability-zone us-east-1a \
    --tag-specifications 'ResourceType=subnet,Tags=[{Key=Name,Value=public-subnet}]'

aws ec2 create-subnet \
    --vpc-id vpc-xxxx \
    --cidr-block 10.0.2.0/24 \
    --availability-zone us-east-1b \
    --tag-specifications 'ResourceType=subnet,Tags=[{Key=Name,Value=private-subnet}]'

# 3. 创建互联网网关
aws ec2 create-internet-gateway \
    --tag-specifications 'ResourceType=internet-gateway,Tags=[{Key=Name,Value=my-igw}]'

# 4. 挂载互联网网关到 VPC
aws ec2 attach-internet-gateway \
    --vpc-id vpc-xxxx \
    --internet-gateway-id igw-xxxx

# 5. 创建路由表
aws ec2 create-route-table \
    --vpc-id vpc-xxxx

# 6. 添加路由规则
aws ec2 create-route \
    --route-table-id rtb-xxxx \
    --destination-cidr-block 0.0.0.0/0 \
    --gateway-id igw-xxxx

# 7. 关联子网到路由表
aws ec2 associate-route-table \
    --subnet-id subnet-xxxx \
    --route-table-id rtb-xxxx

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 创建 VPC 对等连接
aws ec2 create-vpc-peering-connection \
    --vpc-id vpc-xxxx \
    --peer-vpc-id vpc-yyyy

# 接受对等连接（对方账户）
aws ec2 accept-vpc-peering-connection \
    --vpc-peering-connection-id pcx-xxxx

# 配置路由表（双方都需要）
aws ec2 create-route \
    --route-table-id rtb-xxxx \
    --destination-cidr-block 10.1.0.0/16 \
    --vpc-peering-connection-id pcx-xxxx

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 1. 创建弹性 IP
aws ec2 allocate-address --domain vpc

# 2. 创建 NAT 网关
aws ec2 create-nat-gateway \
    --subnet-id subnet-public \
    --allocation-id eip-xxxx

# 3. 在私有子网的路由表中添加路由
aws ec2 create-route \
    --route-table-id rtb-private \
    --destination-cidr-block 0.0.0.0/0 \
    --nat-gateway-id nat-xxxx

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

# 1. 创建 EKS 集群
aws eks create-cluster \
    --name my-cluster \
    --role-arn arn:aws:iam::123456789:role/EKSRole \
    --resources-vpc-config subnetIds=subnet-xxxx,subnet-yyyy,securityGroupIds=sg-xxxx \
    --kubernetes-version 1.28

# 2. 创建节点 IAM 角色（节点要能拉镜像、上报指标、挂载 EBS，所以必须有这个角色）
aws iam create-role \
    --role-name EKSNodeRole \
    --assume-role-policy-document file://trust-policy.json

# 并把必要的托管策略挂上去（示例）
aws iam attach-role-policy --role-name EKSNodeRole \
    --policy-arn arn:aws:iam::aws:policy/AmazonEKSWorkerNodePolicy
aws iam attach-role-policy --role-name EKSNodeRole \
    --policy-arn arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryReadOnly
aws iam attach-role-policy --role-name EKSNodeRole \
    --policy-arn arn:aws:iam::aws:policy/AmazonEKS_CNI_Policy

# 3. 创建节点组
aws eks create-nodegroup \
    --cluster-name my-cluster \
    --nodegroup-name my-nodes \
    --subnets subnet-xxxx subnet-yyyy \
    --instance-types t3.medium \
    --ami-type AL2023_x86_64_STANDARD \
    --node-role arn:aws:iam::123456789:role/EKSNodeRole \
    --scaling-config minSize=1,maxSize=3,desiredSize=2

# 说明：AL2（Amazon Linux 2）正在进入维护期末尾，新集群建议用 AL2023，
# 或使用 Bottlerocket 这类专为容器优化的镜像

# 4. 配置 kubectl
aws eks update-kubeconfig --name my-cluster

# 5. 验证
kubectl get nodes

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# 安装 AWS EBS CSI 驱动
aws eks create-addon \
    --cluster-name my-cluster \
    --addon-name aws-ebs-csi-driver

# 创建 StorageClass
cat > storageclass.yaml << 'EOF'
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: ebs-sc
provisioner: ebs.csi.aws.com
parameters:
  type: gp3
  csi.storage.k8s.io/fstype: ext4
volumeBindingMode: WaitForFirstConsumer
EOF

kubectl apply -f storageclass.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# 安装 VPC CNI 插件
aws eks create-addon \
    --cluster-name my-cluster \
    --addon-name vpc-cni

# 使用 Load Balancer Controller
# 注意：AWS Load Balancer Controller 不是一个"托管 addon"，需要两步：
# 1) 先创建 IAM 角色并绑定官方提供的策略（通过 IRSA 授予权限）
#    参考官方仓库的 iam-policy.json
# 2) 用 Helm 安装 Controller
helm repo add eks https://aws.github.io/eks-charts
helm install aws-load-balancer-controller eks/aws-load-balancer-controller \
    -n kube-system \
    --set clusterName=my-cluster \
    --set serviceAccount.create=false \
    --set serviceAccount.name=aws-load-balancer-controller
# 装好之后，创建 type=LoadBalancer 的 Service 或 Ingress 才会自动生成 ALB/NLB

# 部署应用并暴露服务
kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 创建 Fargate 配置文件
# ⚠️ 重要更正：Fargate Profile 是 **EKS 的资源，不是 Kubernetes 的 CRD**，
# 用 kubectl apply 一个 FargateProfile 清单是无效的（会报找不到该类型）。
# 正确做法是用 AWS CLI 或 eksctl 创建：
aws eks create-fargate-profile \
    --cluster-name my-cluster \
    --fargate-profile-name my-fargate-profile \
    --pod-execution-role-arn arn:aws:iam::123456789:role/EKSFargatePodExecutionRole \
    --selectors namespace=production,labels={env=production} \
    --subnets subnet-xxxx subnet-yyyy

# 查看创建结果
aws eks list-fargate-profiles --cluster-name my-cluster
aws eks describe-fargate-profile \
    --cluster-name my-cluster --fargate-profile-name my-fargate-profile

1
2
3
4
5
6
7
8
9

# 创建一个只读用户（注意：创建后要立刻开启 MFA，不要给它编程访问密钥）
aws iam create-user --user-name auditor

# 把"只读"策略挂上（示例，实际应更细化到具体资源）
aws iam attach-user-policy --user-name auditor \
    --policy-arn arn:aws:iam::aws:policy/ReadOnlyAccess

# 查看某用户当前挂了哪些权限（排查"权限为什么这么大"）
aws iam list-attached-user-policies --user-name auditor

1
2
3
4
5
6

# 快速看看最近有没有"异常的日消费"（需要开启 Cost Explorer 权限）
aws ce get-cost-and-usage \
    --time-period Start=2026-09-01,End=2026-09-14 \
    --granularity DAILY \
    --metrics BlendedCost \
    --group-by Type=DIMENSION,Key=SERVICE