Работа с AWS ALB и Terraform в Unix/Linux

Работа с AWS ALB и Terraform в Unix/Linux

Application Load Balancer работает на уровне запросов (уровень 7), маршрутизируя трафик на целевые объекты – инстансы EC2, контейнеры и IP-адреса – на основе содержимого запроса. Application Load Balancer идеально подходит для расширенной балансировки нагрузки HTTP и HTTPS-трафика. Он обеспечивает расширенную маршрутизацию запросов, ориентированную на доставку приложений, построенных на базе современных архитектур, включая микросервисы и приложения на основе контейнеров. Application Load Balancer упрощает настройку и повышает безопасность приложения, гарантируя, что всегда используются самые новые версии шифров и протоколов SSL/TLS.

Балансировка нагрузки на уровне 7
Имеется возможность осуществлять балансировку нагрузки приложений, использующих протокол HTTP/HTTPS, и использовать особые возможности уровня 7, такие как заголовки X-Forwarded-For.

Поддержка HTTPS
Application Load Balancer поддерживает использование HTTPS-терминации между клиентами и балансировщиком нагрузки. Application Load Balancer также позволяет управлять SSL-сертификатами с помощью AWS Identity and Access Management (IAM) и AWS Certificate Manager для предустановленных политик безопасности.

Server Name Indication (SNI)
Server Name Indication (SNI) – это расширение протокола TLS, с помощью которого клиент обозначает имя узла для подключения в начале установления связи по протоколу TLS. Балансировщик нагрузки может передавать через один и тот же обработчик событий безопасности несколько сертификатов, благодаря чему он способен поддерживать несколько защищенных веб-сайтов через один обработчик событий безопасности. Балансировщики нагрузки приложений также поддерживают интеллектуальный алгоритм выбора сертификатов при работе с SNI. Если имя узла, обозначенное клиентом, соответствует нескольким сертификатам, балансировщик нагрузки определяет наилучший сертификат на основании ряда факторов, в том числе учитывая возможности клиента.

IP-адреса как цели
Применять балансировку нагрузки можно для любого приложения, размещенного в AWS или локально, если использовать в качестве целей IP-адреса серверной части приложения. Это позволяет обеспечить балансировку нагрузки на сервер приложения, размещенный на любом IP-адресе и в любом интерфейсе инстанса. Каждое приложение, размещенное на том же инстансе, может относиться к своей группе безопасности и использовать один и тот же порт. Можно также использовать IP-адреса в качестве целей для приложений с балансировкой нагрузки, размещенных локально (через подключение с помощью Direct Connect или VPN-соединения), в VPC с пиринговым подключением или на инстансах EC2-Classic (с использованием ClassicLink). Возможность балансировки нагрузки между AWS и локальными ресурсами упрощает миграцию в облако, расширение ресурсов в облако или использование облака для обеспечения отказоустойчивости.

Высокая доступность
Для Application Load Balancer необходимо указать более одной зоны доступности. Можно распределять входящий трафик по объектам в нескольких зонах доступности. Application Load Balancer автоматически масштабирует ресурсы, необходимые для обработки запросов, реагируя на входящий трафик приложений.

Возможности обеспечения безопасности
При использовании облака Amazon Virtual Private Cloud (Amazon VPC) можно создать группы безопасности, связанные с Elastic Load Balancing, и управлять ими, чтобы обеспечить дополнительные варианты использования сетевой конфигурации и настройки безопасности. Можно настроить Application Load Balancer для работы с выходом в Интернет или создать балансировщик нагрузки без публичного IP-адреса для работы в качестве внутреннего балансировщика нагрузки (без выхода в Интернет).

Маршрутизация на основе контента
Если приложение состоит из нескольких отдельных сервисов, Application Load Balancer может направлять запрос в определенный сервис на основе содержания запроса.

Маршрутизация на основе узла
Можно выполнять маршрутизацию запросов клиента в зависимости от поля Host HTTP-заголовка – это позволяет из одного и того же балансировщика нагрузки осуществлять маршрутизацию в несколько доменов.

Маршрутизация на основе пути
Можно выполнять маршрутизацию запросов на основе URL-адреса заголовка HTTP.

Поддержка приложений на основе контейнеров
Application Load Balancer обеспечивает расширенную поддержку контейнеров путем балансировки нагрузки между несколькими портами в одном инстансе Amazon EC2. Глубокая интеграция с Amazon EC2 Container Service (ECS) обеспечивает полностью управляемое контейнерное предложение. ECS позволяет в определении задания ECS указать динамический порт, в этом случае контейнеру, запланированному для инстанса EC2, будет передан неиспользуемый порт. Планировщик ECS автоматически добавляет задание в балансировщик нагрузки, используя этот порт.

Поддержка HTTP/2
HTTP/2 – это новая версия протокола передачи гипертекста (HTTP), который использует единое мультиплексное соединение, позволяющее обеспечить отправку нескольких запросов по одному соединению. Он также осуществляет сжатие данных заголовка перед его отправкой в двоичном формате, а также поддерживает установку TLS-соединения с клиентами.

Поддержка WebSocket
WebSocket позволяет серверу в режиме реального времени обмениваться сообщениями с конечными пользователями без необходимости конечных пользователей запрашивать (или опрашивать) этот сервер на наличие обновлений. Протокол WebSocket обеспечивает двунаправленные каналы связи между клиентом и сервером в установленном длительное время TCP-соединении.

Встроенная поддержка протокола IPv6
Application Load Balancer поддерживает работу по интернет-протоколу версии 6 (IPv6) в облаке VPC. Это позволяет клиентам подключаться к Application Load Balancer по протоколам IPv4 или IPv6.

Закрепленные сеансы
Закрепленные сеансы – это механизм маршрутизации запросов из одного и того же клиента к одному и тому же получателю. Application Load Balancer поддерживает закрепленные сеансы с помощью файлов cookie, сгенерированных балансировщиком нагрузки. Если включить закрепленные сеансы, то тот же получатель будет получать запрос и сможет использовать файлы cookie для восстановления контекста сеанса. Закрепленность определяется на уровне целевой группы.

Проверки работоспособности
Application Load Balancer направляет трафик только к работоспособным объектам. С помощью Application Load Balancer можно двумя способами добиться оптимального представления о работоспособности своих приложений. 1) Путем расширенной проверки работоспособности, которая позволяет настроить подробные коды ошибок с 200 по 499. Проверка работоспособности позволяет следить за состоянием каждого из сервисов под управлением балансировщика нагрузки. 2) С помощью новых метрик, которые дают представление о трафике для каждого из сервисов, работающих на инстансе EC2.

Мониторинг в процессе работы
В отчетах Amazon CloudWatch присутствует информация о таких метриках Application Load Balancer, как количество запросов, количество ошибок, тип ошибок и время задержки.

Ведение журналов
Можно использовать возможность ведения журналов доступа для записи всех запросов, отправленных балансировщику нагрузки, и сохранять файлы журналов в Amazon S3 для последующего анализа. Файлы журналов сжаты и имеют расширение .gzip. Сжатые файлы журналов экономят дисковое пространство и пропускную способность при передаче данных и могут использоваться для диагностики сбоев приложений и анализа сетевого трафика.

Можно также использовать AWS CloudTrail для записи вызовов API Application Load Balancer в аккаунте и доставки файлов журналов. История вызовов API позволяет выполнять анализ безопасности, отслеживать изменения ресурсов и аудит соответствия.

Защита от удаления
Можно включить для Application Load Balancer защиту от удаления, чтобы предотвратить возможность его случайного удаления.

Отслеживание запросов
Application Load Balancer вставляет новый пользовательский идентификатор «X-Amzn-Trace-Id» HTTP-заголовка для всех запросов, поступающих в балансировщик нагрузки. Возможность отслеживания запросов позволяет отслеживать запрос по его уникальному ID, поскольку запрос проходит свой путь через различные сервисы, которые являются составляющими ваших веб-сайтов и распределенных приложений. Уникальный идентификатор отслеживания можно использовать для того, чтобы выявить любые проблемы с производительностью или синхронизацией в стеке приложения с детализацией на уровне отдельного запроса.

Web Application Firewall
Теперь можно использовать AWS WAF для защиты интернет-приложений на своих балансировщиках Application Load Balancer. AWS WAF – это брандмауэр для интернет-приложений, который позволяет защитить их от распространенных сетевых эксплойтов, способных повлиять на доступность приложения, создать угрозу безопасности или задействовать чрезмерное количество ресурсов.

Установка terraform в Unix/Linux

Установка крайне примитивная и я описал как это можно сделать тут:

Установка terraform в Unix/Linux

Так же, в данной статье, я создал скрипт для автоматической установки данного ПО. Он был протестирован на CentOS 6/7, Debian 8 и на Mac OS X. Все работает должным образом!

Чтобы получить помощь по использованию команд, выполните:

$ terraform
Usage: terraform [--version] [--help] <command> [args]

The available commands for execution are listed below.
The most common, useful commands are shown first, followed by
less common or more advanced commands. If you're just getting
started with Terraform, stick with the common commands. For the
other commands, please read the help and docs before usage.

Common commands:
    apply              Builds or changes infrastructure
    console            Interactive console for Terraform interpolations
    destroy            Destroy Terraform-managed infrastructure
    env                Workspace management
    fmt                Rewrites config files to canonical format
    get                Download and install modules for the configuration
    graph              Create a visual graph of Terraform resources
    import             Import existing infrastructure into Terraform
    init               Initialize a Terraform working directory
    output             Read an output from a state file
    plan               Generate and show an execution plan
    providers          Prints a tree of the providers used in the configuration
    push               Upload this Terraform module to Atlas to run
    refresh            Update local state file against real resources
    show               Inspect Terraform state or plan
    taint              Manually mark a resource for recreation
    untaint            Manually unmark a resource as tainted
    validate           Validates the Terraform files
    version            Prints the Terraform version
    workspace          Workspace management

All other commands:
    debug              Debug output management (experimental)
    force-unlock       Manually unlock the terraform state
    state              Advanced state management

Приступим к использованию!

Работа с AWS ALB и Terraform в Unix/Linux

У меня есть папка terraform, в ней у меня будут лежать провайдеры с которыми я буду работать. Т.к в этом примере я буду использовать AWS, то создам данную папку и перейду в нее. Далее, в этой папке, стоит создать:

$ mkdir examples modules

В папке examples, я буду хранить так званые «плейбуки» для разварачивания различных служб, например — zabbix-server, grafana, web-серверы и так далее. В modules директории, я буду хранить все необходимые модули.

Начнем писать модуль, но для этой задачи, я создам папку:

$  mkdir modules/alb

Переходим в нее:

$ cd modules/alb

Открываем файл:

$ vim alb.tf

В данный файл, вставляем:

#---------------------------------------------------
# Create AWS ALB
#---------------------------------------------------
resource "aws_lb" "alb" {
    #name_prefix        = "${var.name_prefix}-"
    name                = "${lower(var.name)}-alb-${lower(var.environment)}"
    security_groups     = ["${var.security_groups}"]
    subnets             = ["${var.subnets}"]
    internal            = "${var.lb_internal}"

    enable_deletion_protection  = "${var.enable_deletion_protection}"
    load_balancer_type          = "${var.load_balancer_type}"
    idle_timeout                = "${var.idle_timeout}"
    ip_address_type             = "${var.ip_address_type}"

    access_logs         = ["${var.access_logs}"]

    timeouts {
        create  = "${var.timeouts_create}"
        update  = "${var.timeouts_update}"
        delete  = "${var.timeouts_delete}"
    }

    lifecycle {
        create_before_destroy = true
    }

    tags {
        Name            = "${lower(var.name)}-alb-${lower(var.environment)}"
        Environment     = "${var.environment}"
        Orchestration   = "${var.orchestration}"
        Createdby       = "${var.createdby}"
    }
}
#---------------------------------------------------
# Create AWS LB target group
#---------------------------------------------------
resource "aws_lb_target_group" "alb_target_group" {
    name                 = "${lower(var.name)}-alb-tg-${lower(var.environment)}"
    port                 = "${var.backend_port}"
    protocol             = "${upper(var.backend_protocol)}"
    vpc_id               = "${var.vpc_id}"
    target_type          = "${var.target_type}"
    deregistration_delay = "${var.deregistration_delay}"

    tags {
        Name            = "${lower(var.name)}-alb-tg-${lower(var.environment)}"
        Environment     = "${var.environment}"
        Orchestration   = "${var.orchestration}"
        Createdby       = "${var.createdby}"
    }

    health_check {
        interval            = "${var.health_check_interval}"
        path                = "${var.health_check_path}"
        port                = "${var.health_check_port}"
        healthy_threshold   = "${var.health_check_healthy_threshold}"
        unhealthy_threshold = "${var.health_check_unhealthy_threshold}"
        timeout             = "${var.health_check_timeout}"
        protocol            = "${var.backend_protocol}"
        matcher             = "${var.health_check_matcher}"
    }
    stickiness {
        type            = "lb_cookie"
        cookie_duration = "${var.cookie_duration}"
        enabled         = "${var.cookie_duration != 1 ? true : false}"
    }
}
#---------------------------------------------------
# Create AWS LB listeners
#---------------------------------------------------
resource "aws_lb_listener" "frontend_http" {
    count               = "${trimspace(element(split(",", var.alb_protocols), 1)) == "HTTP" || trimspace(element(split(",", var.alb_protocols), 2)) == "HTTP" ? 1 : 0}"

    load_balancer_arn   = "${aws_lb.alb.arn}"
    port                = "80"
    protocol            = "HTTP"

    "default_action" {
        target_group_arn    = "${aws_lb_target_group.alb_target_group.arn}"
        type                = "forward"
    }

    depends_on = ["aws_lb.alb","aws_lb_target_group.alb_target_group"]
}

resource "aws_lb_listener" "frontend_https" {
    count               = "${trimspace(element(split(",", var.alb_protocols), 1)) == "HTTPS" || trimspace(element(split(",", var.alb_protocols), 2)) == "HTTPS" ? 1 : 0}"

    load_balancer_arn   = "${aws_lb.alb.arn}"
    port                = 443
    protocol            = "HTTPS"
    certificate_arn     = "${var.certificate_arn}"
    ssl_policy          = "ELBSecurityPolicy-2016-08"
    default_action {
        target_group_arn    = "${aws_lb_target_group.alb_target_group.arn}"
        type                = "forward"
    }

    depends_on = ["aws_lb.alb","aws_lb_target_group.alb_target_group"]
}
#---------------------------------------------------
# Create AWS LB target group attachment
#---------------------------------------------------
resource "aws_lb_target_group_attachment" "alb_target_group_attachment" {
    #count               = "${length(var.target_ids)}"

    #availability_zone   = "all"
    target_group_arn    = "${aws_lb_target_group.alb_target_group.arn}"
    target_id           = "${element(var.target_ids, 0)}"
    #target_id           = "${element(var.target_ids, count.index)}"
    #target_id           = "${var.target_ids[count.index]}"
    port                = "${var.backend_port}"

    depends_on = ["aws_lb.alb","aws_lb_target_group.alb_target_group"]
}

Открываем файл:

$ vim variables.tf

И прописываем:

#-----------------------------------------------------------
# Global or/and default variables
#-----------------------------------------------------------
variable "name" {
  description = "Name to be used on all resources as prefix"
  default     = "TEST-ALB"
}

variable "region" {
  description = "The region where to deploy this code (e.g. us-east-1)."
  default     = "us-east-1"
}

variable "environment" {
    description = "Environment for service"
    default     = "STAGE"
}

variable "orchestration" {
    description = "Type of orchestration"
    default     = "Terraform"
}

variable "createdby" {
    description = "Created by"
    default     = "Vitaliy Natarov"
}

variable "security_groups" {
    description = "A list of security group IDs to assign to the ELB. Only valid if creating an ELB within a VPC"
    type        = "list"
}

variable "subnets" {
    description = "A list of subnet IDs to attach to the ELB"
    type        = "list"
    default     = []
}

variable "lb_internal" {
    description = "If true, ALB will be an internal ALB"
    default     = false
}

variable "name_prefix" {
    description = "Creates a unique name beginning with the specified prefix. Conflicts with name"
    default     = "alb"
}

variable "enable_deletion_protection" {
    description = "If true, deletion of the load balancer will be disabled via the AWS API. This will prevent Terraform from deleting the load balancer. Defaults to false."
    default     = false
}

# Access logs
variable "access_logs" {
    description = "An access logs block. Uploads access logs to S3 bucket. Can be used just for network LB!"
    type        = "list"
    default     = []
}

variable "load_balancer_type" {
    description = "The type of load balancer to create. Possible values are application or network. The default value is application."
    default     = "application"
}

variable "idle_timeout" {
    description = "The time in seconds that the connection is allowed to be idle. Default: 60."
    default     = "60"
}

variable "ip_address_type" {
    description = "The type of IP addresses used by the subnets for your load balancer. The possible values are ipv4 and dualstack"
    default     = "ipv4"
}

variable "timeouts_create" {
    description = "Used for Creating LB. Default = 10mins"
    default     = "10m"
}

variable "timeouts_update" {
    description = "Used for LB modifications. Default = 10mins"
    default     = "10m"
}

variable "timeouts_delete" {
    description = "Used for LB destroying LB. Default = 10mins"
    default     = "10m"
}

variable "vpc_id" {
    description = "Set VPC ID for ?LB"
}

variable "alb_protocols" {
    description = "A comma delimited list of the protocols the ALB accepts. e.g.: HTTPS"
    default     = "HTTP,HTTPS"
}

variable "target_type" {
    description = "The type of target that you must specify when registering targets with this target group. The possible values are instance (targets are specified by instance ID) or ip (targets are specified by IP address). The default is instance. Note that you can't specify targets for a target group using both instance IDs and IP addresses. If the target type is ip, specify IP addresses from the subnets of the virtual private cloud (VPC) for the target group, the RFC 1918 range (10.0.0.0/8, 172.16.0.0/12, and 192.168.0.0/16), and the RFC 6598 range (100.64.0.0/10). You can't specify publicly routable IP addresses"
    default     = "instance"
}

variable "deregistration_delay" {
    description = "The amount time for Elastic Load Balancing to wait before changing the state of a deregistering target from draining to unused. The range is 0-3600 seconds. The default value is 300 seconds."
    default     = "300"
}

variable "backend_port" {
    description = "The port the service on the EC2 instances listen on."
    default     = 80
}

variable "backend_protocol" {
    description = "The protocol the backend service speaks. Options: HTTP, HTTPS, TCP, SSL (secure tcp)."
    default     = "HTTP"
}

variable "target_ids" {
    description = "The ID of the target. This is the Instance ID for an instance, or the container ID for an ECS container. If the target type is ip, specify an IP address."
    type        = "list"
    #default     = []
}

variable "certificate_arn" {
    description = "The ARN of the SSL Certificate. e.g. 'arn:aws:iam::XXXXXXXXXXX:server-certificate/ProdServerCert'"
    default     = ""
}

variable "health_check_healthy_threshold" {
    description = "Number of consecutive positive health checks before a backend instance is considered healthy."
    default     = 3
}

variable "health_check_interval" {
    description = "Interval in seconds on which the health check against backend hosts is tried."
    default     = 10
}

variable "health_check_path" {
    description = "The URL the ELB should use for health checks. e.g. /health"
    default     = "/"
}

variable "health_check_port" {
    description = "The port used by the health check if different from the traffic-port."
    default     = "traffic-port"
}

variable "health_check_timeout" {
    description = "Seconds to leave a health check waiting before terminating it and calling the check unhealthy."
    default     = 5
}

variable "health_check_unhealthy_threshold" {
    description = "Number of consecutive positive health checks before a backend instance is considered unhealthy."
    default     = 3
}

variable "health_check_matcher" {
    description = "The HTTP codes that are a success when checking TG health."
    default     = "200-299"
}

variable "cookie_duration" {
    description = "If load balancer connection stickiness is desired, set this to the duration in seconds that cookie should be valid (e.g. 300). Otherwise, if no stickiness is desired, leave the default."
    default     = 1
}

Собственно в этом файле храняться все переменные. Спасибо кэп!

Открываем последний файл:

$ vim outputs.tf

И в него вставить нужно следующие строки:

output "lb_name" {
    description = ""
    value       = "${aws_lb.alb.name}"
}

output "lb_arn" {
    description = "ARN of the lb itself. Useful for debug output, for example when attaching a WAF."
    value       = "${aws_lb.alb.arn}"
}

output "lb_arn_suffix" {
    description = "ARN suffix of our lb - can be used with CloudWatch"
    value       = "${aws_lb.alb.arn_suffix}"
}

output "lb_dns_name" {
    description = "The DNS name of the lb presumably to be used with a friendlier CNAME."
    value       = "${aws_lb.alb.dns_name}"
}

output "lb_id" {
    description = "The ID of the lb we created."
    value       = "${aws_lb.alb.id}"
}

output "lb_zone_id" {
    description = "The zone_id of the lb to assist with creating DNS records."
    value       = "${aws_lb.alb.zone_id}"
}

output "lb_listener_https_arn" {
    description = "The ARN of the HTTPS lb Listener we created."
    value       = "${element(concat(aws_lb_listener.frontend_https.*.arn, list("")), 0)}"
}

output "lb_listener_http_arn" {
    description = "The ARN of the HTTP lb Listener we created."
    value       = "${element(concat(aws_lb_listener.frontend_http.*.arn, list("")), 0)}"
}

output "lb_listener_https_id" {
    description = "The ID of the lb Listener we created."
    value       = "${element(concat(aws_lb_listener.frontend_https.*.id, list("")), 0)}"
}

output "lb_listener_http_id" {
    description = "The ID of the lb Listener we created."
    value       = "${element(concat(aws_lb_listener.frontend_http.*.id, list("")), 0)}"
}

output "target_group_arn" {
    description = "ARN of the target group. Useful for passing to your Auto Scaling group module."
    value       = "${aws_lb_target_group.alb_target_group.arn}"
}

Переходим теперь в папку aws/examples и создадим еще одну папку для проверки написанного чуда:

$ mkdir alb && cd $_

Внутри созданной папки открываем файл:

$ vim main.tf

И вставим в него следующий код:

#
# MAINTAINER Vitaliy Natarov "vitaliy.natarov@yahoo.com"
#
terraform {
  required_version = "> 0.9.0"
}
provider "aws" {
    region                  = "us-east-1"
    shared_credentials_file = "${pathexpand("~/.aws/credentials")}"
    profile                 = "default"
}
module "iam" {
    source                          = "../../modules/iam"
    name                            = "My-Security"
    region                          = "us-east-1"
    environment                     = "PROD"

    aws_iam_role-principals         = [
        "ec2.amazonaws.com",
    ]
    aws_iam_policy-actions           = [
        "cloudwatch:GetMetricStatistics",
        "logs:DescribeLogStreams",
        "logs:GetLogEvents",
        "elasticache:Describe*",
        "rds:Describe*",
        "rds:ListTagsForResource",
        "ec2:DescribeAccountAttributes",
        "ec2:DescribeAvailabilityZones",
        "ec2:DescribeSecurityGroups",
        "ec2:DescribeVpcs",
        "ec2:Owner",
    ]
}
module "vpc" {
    source                              = "../../modules/vpc"
    name                                = "My"
    environment                         = "PROD"
    # VPC
    instance_tenancy                    = "default"
    enable_dns_support                  = "true"
    enable_dns_hostnames                = "true"
    assign_generated_ipv6_cidr_block    = "false"
    enable_classiclink                  = "false"
    vpc_cidr                            = "172.31.0.0/16"
    private_subnet_cidrs                = ["172.31.32.0/20", "172.31.48.0/20"]
    public_subnet_cidrs                 = ["172.31.80.0/20"]
    availability_zones                  = ["us-east-1a", "us-east-1e"]
    enable_all_egress_ports             = "true"
    allowed_ports                       = ["8080", "3306", "443", "80"]

    map_public_ip_on_launch             = "true"

    #Internet-GateWay
    enable_internet_gateway             = "true"
    #NAT
    enable_nat_gateway                  = "false"
    single_nat_gateway                  = "true"
    #VPN
    enable_vpn_gateway                  = "false"
    #DHCP
    enable_dhcp_options                 = "false"
    # EIP
    enable_eip                          = "false"
}
module "ec2" {
    source                              = "../../modules/ec2"
    name                                = "TEST-Machine"
    region                              = "us-east-1"
    environment                         = "PROD"
    number_of_instances                 = 1
    ec2_instance_type                   = "t2.micro"
    enable_associate_public_ip_address  = "true"
    disk_size                           = "8"
    tenancy                             = "${module.vpc.instance_tenancy}"
    iam_instance_profile                = "${module.iam.instance_profile_id}"
    subnet_id                           = "${element(module.vpc.vpc-publicsubnet-ids, 0)}"
    #subnet_id                           = "${element(module.vpc.vpc-privatesubnet-ids, 0)}"
    #subnet_id                           = ["${element(module.vpc.vpc-privatesubnet-ids)}"]
    vpc_security_group_ids              = ["${module.vpc.security_group_id}"]

    monitoring                          = "true"
}
#module "kms" {
#    source               = "../../modules/kms"
#    name                 = "TEST-KMS"
#    environment          = "PROD"
#
#    aws_account_id       = "XXXXXXXXXXXXXXXXX"
#}
#module "s3" {
#    source                              = "../../modules/s3"
#    name                                = "My-backet"
#    environment                         = "PROD"
#
#    #
#    s3_acl          = "log-delivery-write"  #"private"
#    force_destroy   = "true"
#    # Allow public web-site (Static website hosting)
#    website         = [
#    {
#        index_document = "index.html"
#        error_document = "error.html"
#        #redirect_all_requests_to = "https://s3-website.linux-notes.org"
#    },
#    ]
#    # Use cors rules
#    cors_rule       = [
#    {
#        allowed_headers = ["*"]
#        allowed_methods = ["PUT", "POST"]
#        allowed_origins = ["https://s3-website.linux-notes.org"]
#        expose_headers  = ["ETag"]
#        max_age_seconds = 3000
#    },
#    ]
#
#    kms_master_key_id = "arn:aws:kms:${module.kms.region}:${module.kms.aws_account_id}:key/${module.kms.kms_key_id}"
#}
module "alb" {
    source                  = "../../modules/alb"
    name                    = "App-Load-Balancer"
    region                  = "us-east-1"
    environment             = "PROD"

    load_balancer_type          = "application"
    security_groups             = ["${module.vpc.security_group_id}", "${module.vpc.default_security_group_id}"]
    subnets                     = ["${module.vpc.vpc-privatesubnet-ids}"]
    vpc_id                      = "${module.vpc.vpc_id}"
    enable_deletion_protection  = false

    backend_protocol    = "HTTP"
    alb_protocols       = "HTTP"

    target_ids          = ["${module.ec2.instance_ids}"]

    #access_logs = [
    #    {
    #        enabled         = true
    #        bucket          = "${module.s3.bucket_name}"
    #        prefix          = "log"
    #    },
    #]

}

Еще полезности:

Работа с AWS IAM и Terraform в Unix/Linux

Работа с AWS VPC и Terraform в Unix/Linux

Работа с AWS S3 и Terraform в Unix/Linux

Работа с AWS EC2 и Terraform в Unix/Linux

Работа с AWS ASG(auto scaling group) и Terraform в Unix/Linux

Работа с AWS ELB и Terraform в Unix/Linux

Работа с AWS Route53 и Terraform в Unix/Linux

Работа с AWS RDS и Terraform в Unix/Linux

Работа с AWS SNS и Terraform в Unix/Linux

Работа с AWS SQS и Terraform в Unix/Linux

Работа с AWS KMS и Terraform в Unix/Linux

Работа с AWS NLB и Terraform в Unix/Linux

Работа с AWS CloudWatch и Terraform в Unix/Linux

Все уже написано и готово к использованию. Ну что, начнем тестирование. В папке с вашим плейбуком, выполняем:

$ terraform init

Этим действием я инициализирую проект. Затем, подтягиваю модуль:

$ terraform get

PS: Для обновление изменений в самом модуле, можно выполнять:

$ terraform get -update

Проверим валидацию:

$ terraform validate

Запускем прогон:

$ terraform plan

Мне вывело что все у меня хорошо и можно запускать деплой:

$ terraform apply

Как видно с вывода, — все прошло гладко! Чтобы удалить созданное творение, можно выполнить:

$ terraform destroy

Весь материал аплоаджу в github аккаунт для удобства использования:

$ git clone https://github.com/SebastianUA/terraform.git

Вот и все на этом. Данная статья «Работа с AWS ALB и Terraform в Unix/Linux» завершена.

3 thoughts on “Работа с AWS ALB и Terraform в Unix/Linux

  1. Отличная подборка статей. Спасибо за работу.
    Вопрос : Могу ли я с помощью примера из вашей статьи про ALB создать несколько ALB или же при каждом запуске существующий ALB будет стираться и создаваться новый?

    • Можно создать сколько угодно ресурсов через мои модули, например:

      module "alb1" {
      source = "../../modules/alb"
      name = "App-Load-Balancer"
      region = "us-east-1"
      environment = "PROD"

      load_balancer_type = "application"
      security_groups = ["${module.vpc.security_group_id}", "${module.vpc.default_security_group_id}"]
      subnets = ["${module.vpc.vpc-privatesubnet-ids}"]
      vpc_id = "${module.vpc.vpc_id}"
      enable_deletion_protection = false

      backend_protocol = "HTTP"
      alb_protocols = "HTTP"

      target_ids = ["${module.ec2.instance_ids}"]

      }
      module "alb2" {
      source = "../../modules/alb"
      name = "App-Load-Balancer"
      region = "us-east-1"
      environment = "PROD"

      load_balancer_type = "application"
      security_groups = ["${module.vpc.security_group_id}", "${module.vpc.default_security_group_id}"]
      subnets = ["${module.vpc.vpc-privatesubnet-ids}"]
      vpc_id = "${module.vpc.vpc_id}"
      enable_deletion_protection = false

      backend_protocol = "HTTP"
      alb_protocols = "HTTP"

      target_ids = ["${module.ec2.instance_ids}"]

      }

      И так далее…

  2. Это понятно. Спасибо.
    Но как можно(если можно?) используя тот же модуль создавать новые ALB при вторичном запуске? Или это против философии terraform?

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *

Этот сайт использует Akismet для борьбы со спамом. Узнайте как обрабатываются ваши данные комментариев.