Terraform 最佳实践

作者: 华阳_3bcf | 来源:发表于2019-05-23 16:29 被阅读0次

0. 前言

Terraform 的基础用法请参考另一篇文章。

对于复杂的架构，最好的办法就是直接调用已有的官方module，不必自己重复造轮子。当官方的module 不满足需求，或者需要改造的时候，就需要我们自己来写定制化的module了。

换而言之，使用单一模块来实现反复调用，多个模块组合调用（模块1的输出是模块2的输入）。

1. AWS 例子

在AWS 环境，创建一个VM。

1.1 目录结构：

.
├── dev
│   ├── main.tf
│   └── provider.tf
└── modules
    ├── ec2
    │   ├── instance.tf
    │   └── variables.tf
    └── vpc
        ├── networking.tf
        ├── output.tf
        └── variables.tf

modules目录下面两个子目录代表了两个模块，分别用于创建网络和虚拟机，variables.tf 和 output.tf 代表了输入和输出，用于模块的调用和模块的交互。dev目录下tf 文件用于调用module。

1.2 模块文件介绍

1.2.1 vpc部分

下面所有的代码都可以从官网的例子中拷贝，比如搜索“terraform vpc”，然后找示例。

创建VPC 以及子网

# file modules/vpc/networking.tf

resource "aws_vpc" "main" {
  cidr_block       = "${var.vpc_cidr}"

  tags = {
    Name = "RoyVPC"
  }
}

resource "aws_subnet" "main" {
  vpc_id     = "${aws_vpc.main.id}"
  cidr_block = "${var.subnet_cidr}"

  tags = {
    Name = "bastion"
  }
}

当前模块要调用的变量。

# file modules/vpc/variables.tf

variable "vpc_cidr" {
  default = "10.0.0.0/16"
}

variable "subnet_cidr" {
  default = "10.0.1.0/24"
}

其它模块要用到，需要output 输出。

# file modules/vpc/output.tf

output "subnet_id" {
  value = "${aws_subnet.main.id}"
}

1.2.2 ec2部分

这部分创建虚拟机。

# file modules/ec2/instance.tf

resource "aws_instance" "web" {
  ami           = "${var.ami_id}"
  instance_type = "${var.instance_type}"
  subnet_id     = "${var.subnet_id}"
  key_name      = "royzeng"

  tags = {
    Name = "RoyBastion"
  }
}

本模块中用到的变量

# file ec2/variables.tf

variable "instance_type" {
  default = "t2.micro"
}
variable "ami_id" {}
variable "subnet_id" {}

没有output，这是功能测试，不需要向下一个模块传递变量。

1.3 模块调用

# file dev/provider.tf
provider "aws" {
  region     = "us-east-1"
}

上面的部分可以不写，但不写的话，运行时会提醒输入。

# file  dev/main.tf
module "my_vpc" {
  source      = "../modules/vpc"
  vpc_cidr    = "192.168.0.0/16"
  subnet_cidr = "192.168.1.0/24"
}

module "my_ec2" {
  source        = "../modules/ec2"
  ami_id        = "ami-0756fbca465a59a30"
  instance_type = "t2.micro"
  subnet_id     = "${module.my_vpc.subnet_id}"
}

这个文件就是调用了两个模块，source 定义了从哪里调用模块，把变量输入进去。需要注意的是第二个模块，变量里面需要输入前一个模块的输出结果，它的调用格式是

  subnet_id     = "${module.my_vpc.subnet_id}"

表示变量 subnet_id 从模块的实例 my_vpc 中调用 subnet_id，而这个值要从output 去找。这表明了两个模块的联系。（模块 my_vpc 的输出是模块 my_ec2 的输入）

1.4 验证

$ cd dev
$ terraform init
....
$ terraform apply --auto-approve

1.5 实际的例子

上面的例子缺了很多组件，在实践中是没法用的。下面以带有公有子网和私有子网 (NAT) 的 VPC 来举例。

vpc-pub-pri

从这张图可以看出，有太多的组件要部署和配置，网络方面就包括 VPC，subnets, route table, internet gateway, NAT gateway。可以用已有模块来完成，不用自己写代码。（搜索 Terraform VPC module，找到官方模块）。

下面的例子可以用在生产环境中：调用官方vpc模块，部署一系列的组件；调用自定义的模块来创建 instance（vm）。官方模块的输出可以看说明，也可以看output.tf 源码。

# file main.tf
provider "aws" {
  region     = "eu-west-3"
}

module "my_vpc" {
  source = "terraform-aws-modules/vpc/aws"
  version = "~> 2.0"

  name = "roy-vpc"
  cidr = "10.0.0.0/16"

  azs             = ["eu-west-3a",]
  private_subnets = ["10.0.101.0/24",]
  public_subnets  = ["10.0.1.0/24",]

  enable_dns_hostnames   = true
  enable_nat_gateway     = true
  enable_vpn_gateway     = false

  tags = {
    Terraform   = "true"
    Environment = "dev"
  }
}

module "security-group" {
  source  = "terraform-aws-modules/security-group/aws"
  version = "~> 3.0"
  name        = "royweb-sg"
  vpc_id      = "${module.my_vpc.vpc_id}"
  ingress_rules            = ["http-80-tcp", "https-443-tcp", "ssh-tcp"]
  ingress_cidr_blocks      = ["0.0.0.0/0"]
  egress_rules             = ["all-all"]
  egress_cidr_blocks       = ["0.0.0.0/0"]
}


module "my_front_ec2" {
  source                 = "terraform-aws-modules/ec2-instance/aws"
  version                = "~> 2.0"

  name                   = "roy-bastion"
  instance_count         = 1

  ami                    = "ami-0652eb0db9b20aeaf"
  instance_type          = "t2.micro"
  key_name               = "roy-import"
  monitoring             = true
  vpc_security_group_ids = ["${module.my_vpc.default_security_group_id}","${module.security-group.this_security_group_id}"]
  # 用到两个security group，都引入默认的那个，可以保证VCP内部的机器能互联。
  subnet_id              = "${module.my_vpc.public_subnets[0]}"

  tags = {
    Terraform   = "true"
    Environment = "dev"
  }
}

module "appsg" {
  source = "terraform-aws-modules/security-group/aws"
  name        = "app-service"
  description = "Security group for App within VPC"
  vpc_id      = "${module.my_vpc.vpc_id}"


  ingress_with_source_security_group_id = [
    {
    rule                     = "all-all"
    source_security_group_id = "${module.security-group.this_security_group_id}"
    },
  ]

  egress_with_source_security_group_id = [
    {
    rule                     = "all-all"
    source_security_group_id = "${module.security-group.this_security_group_id}"
    },
  ]
}
module "my_backend" {
  source                 = "terraform-aws-modules/ec2-instance/aws"
  version                = "~> 2.0"

  name                   = "roy-backend"
  instance_count         = 2

  ami                    = "ami-0652eb0db9b20aeaf"
  instance_type          = "t2.micro"
  key_name               = "roy-import"
  monitoring             = true
  vpc_security_group_ids = ["${module.my_vpc.default_security_group_id}","${module.appsg.this_security_group_id}"]
  subnet_id              = "${module.my_vpc.private_subnets[0]}"

  tags = {
    Terraform   = "true"
    Environment = "dev"
  }
}

2. Azure例子

这个例子是在Azure 环境创建 vnet 和 subnet，本来可以写得很简单，通过例子理清思路，把逻辑链条搞清楚。

2.1 目录结构：

├── dev
│   └── test.tf
└─── modules
    ├── subnet
    │   ├── output.tf
    │   ├── subnet.tf
    │   └── variables.tf
    └── vnet
        ├── output.tf
        ├── variables.tf
        └── vnet.tf

说明:

modules目录下面两个子目录代表了两个模块，output.tf 和 variables.tf 用于输出和输入。dev目录是代表了实例，实现模块调用；还可以创建多个目录，代表多个实例。

2.2 模块文件介绍

2.2.1 vnet部分

# file vnet/vnet.tf

resource "azurerm_resource_group" "core" {
  name     = "${var.cluster_prefix}-rg"
  location = "${var.cluster_location}"
}

resource "azurerm_virtual_network" "core" {
  name                = "${var.cluster_prefix}-vnet"
  address_space       = ["${var.cluster_cidr}"]
  location            = "${azurerm_resource_group.core.location}"
  resource_group_name = "${azurerm_resource_group.core.name}"
}

这里面创建了 resource group 和 virtual network。里面涉及到了变量，创建下面的文件来定义它们。

# file vnet/variables.tf

variable "cluster_prefix" {
  type        = "string"
  description = "The name of the cluster."
}

variable "cluster_location" {
  type        = "string"
  description = "The Azure region to use https://azure.microsoft.com/en-us/regions/"
}

variable "cluster_cidr" {
  type        = "string"
  description = "The IP range that will be used for the virtual network."
}

有一些结果在之后的模块中要调用，这就需要在当前模块输出。

# file vnet/output.tf

output "cluster_resource_group" {
  value = "${azurerm_resource_group.core.name}"
}

output "virtual_network" {
  value = "${azurerm_virtual_network.core.name}"
}

output "cluster_location" {
  value = "${var.cluster_location}"
}

output "cluster_cidr" {
  value = "${var.cluster_cidr}"
}

2.2.2 subnet部分

# file subnet/subnet.tf
resource "azurerm_subnet" "current" {
  name                 = "${var.subnet_name}"
  resource_group_name  = "${var.cluster_resource_group}"
  virtual_network_name = "${var.virtual_network}"
  address_prefix       = "${var.subnet_cidr}"
}

这里面又出现了 resource group 和 vnet，这在上一个模块中出现过，从这个角度来说，应该把它合并到上一个模块，减少重复的代码。这个例子是为了演示过程，忽略优化问题，在下面文件中重复定义变量。

# file subnet/variables.tf

variable "cluster_resource_group" {}
variable "virtual_network" {}
variable "subnet_name" {}
variable "subnet_cidr" {}

【注意】变量中的 cluster_resource_group 和 virtual_network 是上一个模块的 output。也就是说变量是通过 output 来跨模块传递的。

2.3 模块调用

# file dev/test.tf

module "my_vnet" {
  source           = "../modules/vnet"
  cluster_prefix   = "roytest"
  cluster_location = "eastasia"
  cluster_cidr     = "10.0.0.0/16"
}

module "my_subnet" {
  source                 = "../modules/subnet"
  subnet_name            = "bastion"
  cluster_resource_group = "${module.my_vnet.cluster_resource_group}"
  virtual_network        = "${module.my_vnet.virtual_network}"
  subnet_cidr            = "10.0.1.0/24"
}

这个文件就是调用了两个模块，source 定义了从哪里调用模块，把变量输入进去。需要注意的是第二个模块，变量里面需要输入前一个模块的输出结果，它的调用格式是

  cluster_resource_group = "${module.my_vnet.cluster_resource_group}"
  virtual_network        = "${module.my_vnet.virtual_network}"

${module.my_vnet.virtual_network} ，module 表示从模块里面获取，my_vnet 是实例的名字（不是模块的名字vnet），virtual_network 这个名字要与模块中的output输出相匹配。

前面是大量的铺垫，这一部分才是核心内容，表明了跨模块怎么实现调用的。

2.4 验证

$ cd dev
$ terraform init
....
$ terraform apply --auto-approve

3. 改造自己的 module

从官网 Registry 找到对应模块，确定对应 github 地址，克隆下来，修改对应的内容，于是就成了自定义模块。

涉及到的核心知识点在上面的例子中已经说明，具体改造情况（略）。

网友评论

DevOps

本文标题：Terraform 最佳实践

本文链接：https://www.haomeiwen.com/subject/sgdbzqtx.html

延伸阅读

深度阅读

您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！