目录划分如下：首先是环境，分为网络和service。global是全局的配置，也就是backend的配置，这次使用s3的存储作为backend的存储。最后就是模块做了一些封装。

在global里面的backend里面的main.tf去创建s3的存储。华为云支持s3存储，所以这里可以使用。

定义好了ak sk信息就需要去创建s3存储了。

在指定provider里面的信息的时候，因为ak sk信息已经环境变量里面声明了，只需要声明region。

provider "huaweicloud" {
  region = var.region
}

因为华为云使用的是s3存储，s3默认是aws这块的，所以这里需要声明aws的ak sk信息。 其实值都是华为的账号，但是变量还是加上aws的。

然后后面创建bucket的信息。

resource "huaweicloud_obs_bucket" "bucket" {
  region = var.region
  bucket = "test-backend-bucket"
  multi_az = true
  acl    = "private"
  tags = {
    type = "bucket"
  }
}

创建好了bucket然后就是配置使用backend。AWS_ACCESS_KEY_ID和AWS_SECRET_ACCESS_KEY要定义一下。

terraform {
  backend "s3" {
    bucket   = "test-backend-bucket"
    key      = "global/backend/terraform-global-backend.tfstate"
    region   = "cn-east-3"
    endpoint = "obs.cn-east-3.myhuaweicloud.com"

    skip_region_validation      = true
    skip_metadata_api_check     = true
    skip_credentials_validation = true
  }
}

传到云端之后就可以将这个stat文件删除了。注意就是使用backend要将aws的key给加上。

如果你是Windows系统，那么环境变量去高级系统配置里面去配置，然后去重启的你vv code就可以成功加载你的环境变量了。

可以看到文件信息存储上去了，本地之前创建bucket的state.tf文件就可以手动删除了。

 

VPC 安全组定义

---

之后在network下面创建其backend。

terraform {
  backend "s3" {
    bucket   = "test-backend-bucket"
    key      = "env/dev/network/terraform-dev-network.tfstate"
    region   = "cn-east-3"
    endpoint = "obs.cn-east-3.myhuaweicloud.com"

    skip_region_validation      = true
    skip_metadata_api_check     = true
    skip_credentials_validation = true
  }
}

配置好backend之后就去init一下。

init完之后就去模块化资源，然后创建vpc和安全组。（反正就是注意使用variable去定义模块需要传入的参数和output模块需要输出的参数）

注意vpc里面需要设置gateway的IP，这是一个特殊的地方。

resource "huaweicloud_vpc" "vpc" {
  name = var.vpc_name
  cidr = var.vpc_cidr
}

resource "huaweicloud_vpc_subnet" "subnet" {
  name       = var.subnet_name
  cidr       = var.subnet_cidr
  gateway_ip = var.subnet_gateway_ip
  vpc_id     = huaweicloud_vpc.vpc.id
  availability_zone = var.availability_zone
}

接下来就是创建安全组和规则了。

网络这块是单独使用state进行存储的，后面在创建ecs和service的时候，需要使用到这里的输出，所以需要将vpc和subnet的id都得拿出来。（这个是在service模块调用的时候使用的输出）

output "vpc_id" {
  value = module.dev-vpc.vpc_id
}

output "subnet_id" {
  value = module.dev-vpc.subnet_id
}

output "subnet_subnet_id" {
  value = module.dev-vpc.subnet_subnet_id
}

output "secgroup_id" {
  value = module.dev-secgroup.secgroup_id
}

 

 

 ecs

---

network搞定了，后面就是创建service目录。

这里ecs所需要的id都需要通过远程的数据源去拿到，我们需要network里面提供的state，那就需要读取远程的state。

data "terraform_remote_state" "network" {
  backend = "s3"
  config = {
    bucket   = "test-backend-bucket"
    key      = "env/dev/network/terraform-dev-network.tfstate"
    region   = "cn-east-3"
    endpoint = "obs.cn-east-3.myhuaweicloud.com"

    skip_region_validation      = true
    skip_metadata_api_check     = true
    skip_credentials_validation = true
  }
}

output里面两个输出，一个是当前实例的id，一个是当前实例的ip，因为后面elb是需要挂载ecs的，所以需要拿到内网的IP。

output "instance_id" {
    value = huaweicloud_compute_instance.basic.id
  
}

output "instance_ip" {
    value = huaweicloud_compute_instance.basic.access_ip_v4
}

 

 

 

 申请eip然后绑定eip

---

上面创建的ecs两台没有公网ip，所以这里需要关联上，这里要关联上eip使用yum去安装。

这里创建了公共的带宽，也就是共享带宽，然后将弹性公网ip加入这个池就行了。

所以第一步创建共享的带宽，然后下面是创建eip，eip的个数和ecs主机的数量一样。

resource "huaweicloud_vpc_bandwidth" "bandwidth_1" {
  name = var.bandwidth_name
  size = 5
}

resource "huaweicloud_vpc_eip" "eip" {
  count = length(var.instances)
  publicip {
    type = "5_bgp"
  }
  bandwidth {
    share_type = "WHOLE"
    id         = huaweicloud_vpc_bandwidth.bandwidth_1.id
  }
}

 然后eip和实例关联上

resource "huaweicloud_compute_eip_associate" "associated" {
  count = length(var.instances)
  public_ip   = huaweicloud_vpc_eip.eip[*].address[count.index]
  instance_id = var.instances[count.index]
}

可以看到count不仅可以在模块当中使用也可以在resource当中使用。

最后导入模块。 

locals {
  bandwidth_name = "dev-bandwidth"
  instances      = module.dev-ecs[*].instance_id
}


module "dev-eip" {
  source         = "../../../module/eip"
  bandwidth_name = local.bandwidth_name
  instances      = local.instances
}

共享带宽创建

将eip加入共享带宽 

然后访问弹性公网，看看是否可以访问到站点

可以看到公网ip就分别绑定了不太的ecs。

 

 

创建elb关联之前创建的ecs

---

其实就是负载均衡实例+监听器就行了。

首先拿到subnet的id

resource "huaweicloud_lb_loadbalancer" "lb" {
  vip_subnet_id = var.subnet_id
}

 然后是listener，监听80端口

resource "huaweicloud_lb_listener" "listener" {
  protocol        = "HTTP"
  protocol_port   = 80
  loadbalancer_id = huaweicloud_lb_loadbalancer.lb.id
}

 然后是地址池子，其实就是服务器组。

resource "huaweicloud_lb_member" "member" {
  count = length(var.instance_ips)
  address       = var.instance_ips[count.index]
  protocol_port = 80
  pool_id       = huaweicloud_lb_pool.pool.id
  subnet_id     = var.subnet_id
}

每个ecs实例其实就是有个member，然后将member加入到这里面来。

elb关联的是子网的id。

用的是这个id号，子网id。 

output "subnet_subnet_id" {
    value = huaweicloud_vpc_subnet.subnet.subnet_id
}

 这里也拿到了所有的instance_ip，通过在模块ecs里面output输出。

module "dev-elb" {
  source       = "../../../module/elb"
  subnet_id    = data.terraform_remote_state.network.outputs.subnet_subnet_id
  instance_ips = module.dev-ecs[*].instance_ip
}

这里创建的eip还是使用之前的共享带宽

resource "huaweicloud_vpc_eip" "elb-eip" {
  publicip {
    type = "5_bgp"
  }
  bandwidth {
    share_type = "WHOLE"
    id         = module.dev-eip.bandwidth_id
  }
}

 端口和eip绑定即可

resource "huaweicloud_networking_eip_associate" "eip_elb" {
  public_ip = huaweicloud_vpc_eip.elb-eip.address
  port_id   = module.dev-elb.elb_vip_port_id
}