enscalator 0.4.0.pre.alpha.pre.16

data/lib/enscalator/plugins/amazon_linux.rb

@@ -0,0 +1,93 @@
+module Enscalator
+  module Plugins
+    # Amazon Linux appliance
+    module AmazonLinux
+      class << self
+        # Supported storage types in AWS
+        STORAGE = [:ebs, :'instance-store']
+
+        # Supported EBS volume types
+        EBS_VOLUME_TYPES = [:standard, :gp2]
+
+        # Supported Debian image architectures
+        ARCH = [:x86_64, :i386]
+
+        # @param [Symbol, String] region name
+        # @param [Symbol, String] release a codename or version number
+        # @param [Symbol] storage storage kind
+        # @param [Symbol] arch architecture
+        # @param [Symbol] ebs_type (:standard or :gp2)
+        # @param [Hash] filters search filters
+        # @raise [ArgumentError] if storage is nil, empty or not one of supported values
+        # @raise [ArgumentError] if arch is nil, empty or not one of supported values
+        # @return [String] first ami-id found for the query
+        def get_ami(region:, release: '2015.09.1', storage: :ebs, arch: :x86_64, ebs_type: :gp2, filters: {})
+          fail ArgumentError, "storage can only be one of #{STORAGE}" unless STORAGE.include? storage
+          fail ArgumentError, "arch can only be one of #{ARCH}" unless ARCH.include? arch
+          fail ArgumentError, "ebs_type can only be one of #{EBS_VOLUME_TYPES}" unless EBS_VOLUME_TYPES.include? ebs_type
+
+          client = Aws::EC2::Client.new(region: region)
+
+          resp = client.describe_images(
+            owners: ['amazon'],
+            filters: [
+              {
+                name: 'name',
+                values: %W(amzn-ami-hvm-#{release}* amzn-ami-pv-#{release}*)
+              },
+              {
+                name: 'root-device-type',
+                values: [storage.to_s]
+              },
+              {
+                name: 'architecture',
+                values: [arch.to_s]
+              }
+            ] + filters_map_to_array(filters)
+          )
+
+          err_msg = format('Could not find any Linux Amazon Ami that fits the criteria: %s, %s, %s, %s, %s, %s',
+                           region, release, storage, arch, ebs_type, filters)
+          fail StandardError, err_msg unless resp.images
+
+          images = resp.images.sort_by(&:creation_date).reverse
+          images = images.select { |i| i.block_device_mappings.first.ebs.volume_type == ebs_type.to_s } if storage == :ebs
+          images.first.image_id
+        end
+
+        private
+
+        def filters_map_to_array(filters)
+          filters.map do |k, v|
+            {
+              name: k.to_s,
+              values: v.is_a?(Array) ? v : [v.to_s]
+            }
+          end
+        end
+      end
+
+      # Create AMI id parameter for an Amazon linux instance
+      #
+      # @param [Symbol, String] region name
+      # @param [Symbol, String] release a codename or version number
+      # @param [Symbol] storage storage kind (ebs or instance_store)
+      # @param [String] arch architecture (x86_64 or i386)
+      # @param [Symbol] ebs_type (:standard or :gp2)
+      # @param [Hash] filters filters for the search
+      def amazon_linux_init(region: self.region,
+                            release: '2015.09.1',
+                            storage: :ebs,
+                            arch: :x86_64,
+                            ebs_type: :gp2,
+                            filters: {})
+        parameter_ami 'AmazonLinux', AmazonLinux.get_ami(region: region,
+                                                         release: release,
+                                                         storage: storage,
+                                                         arch: arch,
+                                                         ebs_type: ebs_type,
+                                                         filters: filters)
+      end
+    end # class AmazonLinux
+  end # module Plugins
+end # module Enscalator

data/lib/enscalator/plugins/auto_scale.rb

@@ -0,0 +1,80 @@
+module Enscalator
+  module Plugins
+    # Auto scaling group plugin
+    module AutoScale
+      # Create new auto scaling group
+      #
+      # @param [String] image_id image id that will be used to launch instance
+      # @param [String] auto_scale_name auto scaling group name (default: stack name)
+      # @param [Hash] launch_config_props dictionary that is used to overwrite default launch configuration settings
+      #               Reference: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-as-launchconfig.html
+      # @param [Hash] auto_scale_props dictionary that is used to overwrite default auto scaling group settings
+      #               Reference: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-as-group.html
+      # @param [Array] auto_scale_tags list of tags that is added to auto scaling group tags
+      # @return [String] auto scaling group resource name
+      def auto_scale_init(image_id,
+                          auto_scale_name: nil,
+                          launch_config_props: {},
+                          auto_scale_props: {},
+                          auto_scale_tags: [])
+
+        name = auto_scale_name || app_template_name
+        auto_scale_name = "#{name}AutoScale"
+        launch_config_resource_name = "#{name}LaunchConfig"
+        auto_scale_resource_name = auto_scale_name
+        auto_scale_key_name = gen_ssh_key_name auto_scale_name.underscore, region, stack_name
+
+        pre_run do
+          create_ssh_key auto_scale_key_name,
+                         region,
+                         force_create: false
+        end
+
+        resource launch_config_resource_name,
+                 Type: 'AWS::AutoScaling::LaunchConfiguration',
+                 Properties: {
+                   ImageId: image_id,
+                   InstanceType: 'm3.medium',
+                   KeyName: auto_scale_key_name,
+                   AssociatePublicIpAddress: false,
+                   SecurityGroups: [ref_private_security_group, ref_application_security_group]
+                 }.merge(launch_config_props)
+
+        if auto_scale_props.key?(:Tags)
+          warn('Do not use auto_scale_props to set Tags, auto_scale_tags is available for that purpose')
+          auto_scale_props.delete_if { |k, _| k == :Tags }
+        end
+
+        auto_scale_current_tags = [
+          {
+            Key: 'Name',
+            Value: auto_scale_name,
+            PropagateAtLaunch: true
+          }
+        ].concat(auto_scale_tags)
+
+        auto_scale_current_properties = {
+          AvailabilityZones: availability_zones.values,
+          VPCZoneIdentifier: ref_application_subnets,
+          LaunchConfigurationName: ref(launch_config_resource_name),
+          MinSize: 0,
+          MaxSize: 1,
+          DesiredCapacity: 1,
+          Tags: auto_scale_current_tags
+        }.merge(auto_scale_props)
+
+        resource auto_scale_resource_name,
+                 Type: 'AWS::AutoScaling::AutoScalingGroup',
+                 Properties: auto_scale_current_properties
+
+        # return resource name
+        auto_scale_resource_name
+      end
+
+      # Callback to get name of the class which included this module
+      def self.included(klass)
+        send(:define_method, :app_template_name) { "#{klass.name.demodulize}" }
+      end
+    end # module AutoScale
+  end # module Plugins
+end # module Enscalator

data/lib/enscalator/plugins/core_os.rb

@@ -0,0 +1,88 @@
+module Enscalator
+  module Plugins
+    # CoreOS appliance
+    module CoreOS
+      class << self
+        # CoreOS Release channels
+        # @see https://coreos.com/releases
+        CHANNELS = [:alpha, :beta, :stable].freeze
+
+        # Get CoreOS mapping for specific version from specific channel (stable, beta or alpha)
+        #
+        # @param [Symbol] channel channel identifier
+        # @param [String] tag specific version release tag
+        # @return [Hash] CoreOS mapping for specific version and channel
+        #  (if version tag is not given, returns the most latest version number)
+        def get_channel_version(channel: :stable, tag: nil)
+          fail ArgumentError, "channel can only be one of #{CHANNELS}" unless CHANNELS.include? channel
+          base_url = "http://#{channel}.release.core-os.net/amd64-usr"
+          fetch_mapping(base_url, tag)
+        end
+
+        # Get CoreOS mapping for specific version regardless of its release channel
+        #
+        # @param [String] tag version tag
+        # @return [Hash] CoreOS mapping for specific version
+        #  (if version tag is not given, returns the most latest version number)
+        def get_specific_version(tag: nil)
+          urls = CHANNELS.map { |c| "http://#{c}.release.core-os.net/amd64-usr" }
+          mapping = nil
+          urls.each do |u|
+            mapping ||= fetch_mapping(u, tag)
+          end
+          mapping
+        end
+
+        private
+
+        # Fetch CoreOS region/virtualization/ami mapping
+        #
+        # @param [String] base_url url excluding version number and mapping file
+        # @param [String] tag specific version release tag
+        # @return [Hash] CoreOS mapping
+        def fetch_mapping(base_url, tag)
+          fail ArgumentError, 'url cannot be empty or nil' if base_url.blank?
+          versions = fetch_versions(base_url.ends_with?('/') ? base_url : base_url + '/')
+          version = if tag && !tag.empty?
+                      versions.find { |v| v == Semantic::Version.new(tag) }.to_s
+                    else
+                      versions.sort.last.to_s
+                    end
+
+          images = open([base_url, version, 'coreos_production_ami_all.json'].join('/')) { |f| f.read }
+
+          json = JSON.parse(images) if images
+          parse_raw_mapping(json)
+        end
+
+        # Make request to CoreOS release pages, parse response and make a list of versions
+        #
+        # @param [String] url of web page with CoreOS versions
+        # @return [Array] list of Semantic::Version
+        def fetch_versions(url)
+          html = Nokogiri::HTML(open(url))
+          raw_versions = html.xpath('/html/body/a').map { |a| a.children.first.text.chomp('/') }
+          raw_versions.select { |rw| rw =~ /^[0-9]/ }.map { |rw| Semantic::Version.new(rw) }
+        end
+
+        # Parse and reformat CoreOS default mapping
+        #
+        # @param [Array] coreos_mapping list of region to virtualization kind mappings
+        # @return [Hash] mapping, that can be referred to with find_in_map
+        def parse_raw_mapping(coreos_mapping)
+          return {} unless coreos_mapping
+          amis = coreos_mapping.empty? ? [] : coreos_mapping['amis']
+          Hash[
+            amis.map { |a| [a['name'], { pv: a['pv'], hvm: a['hvm'] }] }
+          ].with_indifferent_access
+        end
+      end # class << self
+
+      # Initialize CoreOS related configurations
+      #
+      def core_os_init
+        mapping 'AWSCoreOSAMI', CoreOS.get_channel_version(channel: :stable)
+      end
+    end # module CoreOS
+  end # module Plugins
+end # module Enscalator

data/lib/enscalator/plugins/couchbase.rb

@@ -0,0 +1,98 @@
+module Enscalator
+  module Plugins
+    # Plugin for Couchbase
+    module Couchbase
+      # Couchbase instance
+      #
+      # @param [String] db_name database name
+      # @param [String] bucket bucket
+      # @param [Integer] allocated_storage size of instance primary storage
+      # @param [String] instance_type instance type
+      def couchbase_init(db_name,
+                         bucket: nil,
+                         allocated_storage: 5,
+                         instance_type: 't2.medium')
+        @couchbase_mapping ||=
+          mapping 'AWSCouchbaseAMI', couchbase_ami_mapping
+
+        fail 'You need to provide a bucket for couchbase' if bucket.nil?
+
+        parameter_key_name "Couchbase#{db_name}"
+
+        parameter_allocated_storage "Couchbase#{db_name}",
+                                    default: allocated_storage,
+                                    min: 5,
+                                    max: 1024
+
+        parameter_ec2_instance_type "Couchbase#{db_name}", type: instance_type
+
+        instance_vpc("Couchbase#{db_name}",
+                     find_in_map('AWSCouchbaseAMI', ref('AWS::Region'), 'amd64'),
+                     ref_resource_subnets.first,
+                     [ref_private_security_group, ref_resource_security_group],
+                     depends_on: [],
+                     properties: {
+                       KeyName: ref("Couchbase#{db_name}KeyName"),
+                       InstanceType: ref("Couchbase#{db_name}InstanceType"),
+                       UserData: Base64.encode64(
+                         couchbase_user_data(bucket, 'Administrator', '3fA76JWtzYbm')
+                       )
+                     })
+      end
+
+      # Couchbase ami mapping for x64 images
+      # @return [Hash] aws mapping
+      def couchbase_ami_mapping
+        {
+          'us-west-2': { paravirtual: 'ami-c398c6f3' },
+          'us-west-1': { paravirtual: 'ami-1a554c5f' },
+          'us-east-1': { paravirtual: 'ami-403b4328' },
+          'sa-east-1': { paravirtual: 'ami-59229f44' },
+          'eu-west-1': { paravirtual: 'ami-8129aaf6' },
+          'ap-southeast-1': { paravirtual: 'ami-88745fda' },
+          'ap-northeast-1': { paravirtual: 'ami-6a7b676b' }
+        }.with_indifferent_access
+      end
+
+      # Couchbase user data
+      #
+      # @param [String] bucket couchbase bucket
+      # @return [String] user data script
+      def couchbase_user_data(bucket, user, password)
+        data = <<-EOG
+          #!/usr/bin/env bash
+          while [[ ! -e /opt/couchbase/var/lib/couchbase/couchbase-server.pid ]]; do
+            sleep 20
+            echo "wait for couchbase" >> /tmp/userdatalog
+            service couchbase-server status >> /tmp/userdatalog
+          done
+
+          # Wait for everything to be initialized
+          sleep 1m
+          RAMSIZE=`cat /proc/meminfo | grep MemTotal | awk {'print $2'}`
+          RAMSIZE=`echo "($RAMSIZE/1000*(75/100.0))" | bc -l | xargs printf %0.f`
+          INSTANCE=`curl http://169.254.169.254/latest/meta-data/instance-id`
+          /opt/couchbase/bin/couchbase-cli cluster-init -c 127.0.0.1:8091 \
+            -u #{user} \
+            -p $INSTANCE \
+            --cluster-init-password=#{password} \
+            --cluster-init-ramsize=$RAMSIZE 2>&1 >> /tmp/userdatalog
+          /opt/couchbase/bin/couchbase-cli node-init -c 127.0.0.1:8091 \
+            -u #{user} \
+            -p #{password} 2>&1 >> /tmp/userdatalog
+          /opt/couchbase/bin/couchbase-cli bucket-create -c 127.0.0.1:8091 \
+             --bucket=#{bucket} \
+             --bucket-type=couchbase \
+             --bucket-password=#{password} \
+             --bucket-port=11211 \
+             --bucket-ramsize=$RAMSIZE \
+             --bucket-replica=1 \
+             --bucket-priority=low \
+             --wait \
+             -u #{user} -p #{password} 2>&1 >> /tmp/userdatalog
+        EOG
+        data
+      end
+    end # module Couchbase
+  end # module Plugins
+end # module Enscalator

data/lib/enscalator/plugins/debian.rb

@@ -0,0 +1,71 @@
+module Enscalator
+  module Plugins
+    # Debian appliance
+    module Debian
+      class << self
+        # Supported storage types in AWS
+        STORAGE = [:ebs, :'instance-store']
+
+        # Supported Debian image architectures
+        ARCH = [:x86_64, :i386]
+
+        # Supported Debian releases
+        RELEASE = { jessie: '8', wheezy: '7' }
+
+        # Structure to hold parsed record
+        Struct.new('Debian', :region, :ami, :virtualization, :arch, :root_storage)
+
+        # @param [Symbol, String] release a codename or version number
+        # @param [Symbol] storage storage kind
+        # @param [Symbol] arch architecture
+        # @raise [ArgumentError] if release is nil, empty or not one of supported values
+        # @raise [ArgumentError] if storage is nil, empty or not one of supported values
+        # @raise [ArgumentError] if arch is nil, empty or not one of supported values
+        # @return [Hash] mapping for Debian amis
+        def get_mapping(release: :jessie, storage: :ebs, arch: :x86_64)
+          fail ArgumentError, 'release can be either codename or version' unless RELEASE.to_a.flatten.include? release
+          fail ArgumentError, "storage can only be one of #{STORAGE}" unless STORAGE.include? storage
+          fail ArgumentError, "arch can only be one of #{ARCH}" unless ARCH.include? arch
+          version = RELEASE.keys.include?(release) ? release : RELEASE.invert[release]
+          url = "https://wiki.debian.org/Cloud/AmazonEC2Image/#{version.capitalize}?action=raw"
+          body = open(url) { |f| f.read }
+          parse_raw_entries(body.split("\r\n").select { |b| b.starts_with?('||') })
+            .select { |i| i.ami =~ /ami[-][a-z0-9]{8}/ }
+            .select { |r| r.root_storage == storage.to_s && r.arch == arch.to_s }
+            .group_by(&:region)
+            .map { |k, v| [k, v.map { |i| [i.virtualization, i.ami] }.to_h] }
+            .to_h
+            .with_indifferent_access
+        end
+
+        private
+
+        # Parse raw entries and convert them to meaningful structs
+        #
+        # @param [Array] items in its raw form
+        def parse_raw_entries(items)
+          header, *entries = items.map do |item|
+            if (item.include?('Region'))..(item.include?('paravirtual'))
+              item.downcase.split('||').map(&:strip).map { |i| i.delete("'") }.reject(&:empty?)
+            end
+          end.compact
+          amis = entries.select { |e| e.first =~ /[a-z]{2}-/ }.flat_map do |entry|
+            region, *images = entry
+            images.map.with_index(1).map do |ami, i|
+              [region, ami, header[i].nil? ? '' : header[i].split].flatten
+            end
+          end
+
+          amis.map { |a| Struct::Debian.new(*a) }
+        end
+      end
+      # Create new Debian instance
+      #
+      # @param [String] storage storage kind (usually ebs or ephemeral)
+      # @param [String] arch architecture (amd64 or i386)
+      def debian_init(storage: :ebs, arch: :x86_64)
+        mapping 'AWSDebianAMI', Debian.get_mapping(storage: storage, arch: arch)
+      end
+    end # class Debian
+  end # module Plugins
+end # module Enscalator

data/lib/enscalator/plugins/elastic_beanstalk.rb

@@ -0,0 +1,74 @@
+module Enscalator
+  module Plugins
+    # Collection of methods to work with Elastic Beanstalk
+    module ElasticBeanstalk
+      include Enscalator::Helpers
+
+      # Create new ElasticBeanstalk instance
+      #
+      # @param [String] app_name application name
+      # @param [String] ssh_key name of ssh key to configure instance with
+      # @param [String] solution_stack_name stack name of Elastic Beanstalk solution
+      # @param [String] instance_type default instance type
+      def elastic_beanstalk_app(app_name,
+                                stack_name,
+                                ssh_key: app_name,
+                                solution_stack_name: '64bit Amazon Linux 2015.09 v2.0.4 running Ruby 2.2 (Passenger Standalone)',
+                                instance_type: 't2.small')
+
+        properties = {
+          ApplicationName: app_name,
+          Description: "#{app_name} in #{stack_name} stack",
+          ConfigurationTemplates:
+            [
+              {
+                TemplateName: 'DefaultConfiguration',
+                Description: 'Default Configuration Version 1.0 - with SSH access',
+                SolutionStackName: solution_stack_name,
+                OptionSettings: [
+                  {
+                    'Namespace': 'aws:autoscaling:launchconfiguration',
+                    'OptionName': 'EC2KeyName',
+                    'Value': ssh_key
+                  },
+                  {
+                    'Namespace': 'aws:ec2:vpc',
+                    'OptionName': 'VPCId',
+                    'Value': vpc.id
+                  },
+                  {
+                    'Namespace': 'aws:ec2:vpc',
+                    'OptionName': 'Subnets',
+                    'Value': { 'Fn::Join': [',', ref_application_subnets] }
+                  },
+                  {
+                    'Namespace': 'aws:ec2:vpc',
+                    'OptionName': 'ELBSubnets',
+                    'Value': { 'Fn::Join': [',', public_subnets] }
+                  },
+                  {
+                    'Namespace': 'aws:autoscaling:launchconfiguration',
+                    'OptionName': 'SecurityGroups',
+                    'Value': { 'Fn::Join': [',', [ref_application_security_group, ref_private_security_group]] }
+                  },
+                  {
+                    'Namespace': 'aws:autoscaling:launchconfiguration',
+                    'OptionName': 'InstanceType',
+                    'Value': instance_type
+                  }
+                ]
+              }
+            ]
+        }
+
+        elastic_beanstalk_resource_name = "#{app_name}BeanstalkApp"
+
+        resource elastic_beanstalk_resource_name,
+                 Type: 'AWS::ElasticBeanstalk::Application',
+                 Properties: properties
+
+        elastic_beanstalk_resource_name
+      end
+    end # module ElasticBeanstalk
+  end # module Plugins
+end # module Enscalator

data/lib/enscalator/plugins/elasticache.rb

@@ -0,0 +1,168 @@
+module Enscalator
+  module Plugins
+    # Collection of methods to work with ElastiCache (Redis)
+    module Elasticache
+      include Enscalator::Helpers
+
+      # Generates magic number (sha256 hex digest) from given Hash
+      # @param [Object] input used for digest generation
+      # @return [String]
+      def magic_number(input)
+        str = if input.is_a?(String)
+                input
+              elsif input.is_a?(Array)
+                input.flatten.map(&:to_s).sort.join('&')
+              elsif input.is_a?(Hash)
+                flatten_hash(input).map { |k, v| "#{k}=#{v}" }.sort.join('&')
+              else
+                fail("Not supported input format: #{input.class}")
+              end
+        Digest::SHA256.hexdigest(str)
+      end
+
+      # Initialize resources common for all ElastiCache instances
+      # @param [Object] app_name application stack name
+      # @param [Object] cache_node_type node type
+      def init_cluster_resources(app_name, cache_node_type, param_group_seed: nil, **properties)
+        subnet_group_name = "#{app_name}ElasticacheSubnetGroup"
+        resource subnet_group_name,
+                 Type: 'AWS::ElastiCache::SubnetGroup',
+                 Properties: {
+                   Description: 'SubnetGroup for elasticache',
+                   SubnetIds: ref_resource_subnets
+                 }
+
+        security_group_name =
+          security_group_vpc "#{app_name}RedisSecurityGroup",
+                             "Redis Security Group for #{app_name}",
+                             ref_vpc_id,
+                             security_group_ingress: [
+                               {
+                                 IpProtocol: 'tcp',
+                                 FromPort: '6379',
+                                 ToPort: '6389',
+                                 SourceSecurityGroupId: ref_application_security_group
+                               }
+                             ],
+                             tags: {
+                               Name: join('-', aws_stack_name, 'res', 'sg'),
+                               Application: aws_stack_name
+                             }
+
+        parameter_group_required_props = {
+          'reserved-memory': Core::InstanceType.elasticache_instance_type.max_memory(cache_node_type) / 2
+        }
+
+        parameter_group_props = (
+        if !properties.nil? && properties.key?(:parameter_group_properties)
+          properties[:parameter_group_properties]
+        else
+          {}
+        end).merge(parameter_group_required_props)
+
+        # TODO: remove this workaround when related template gets fixed
+        parameter_group_name = if param_group_seed
+                                 "#{app_name}RedisParameterGroup#{param_group_seed}"
+                               else
+                                 "#{app_name}RedisParameterGroup#{magic_number(parameter_group_props)}"
+                               end
+
+        resource parameter_group_name,
+                 Type: 'AWS::ElastiCache::ParameterGroup',
+                 Properties: {
+                   Description: "#{app_name} redis parameter group",
+                   CacheParameterGroupFamily: 'redis3.2',
+                   Properties: parameter_group_props
+                 }
+
+        {
+          subnet_group: subnet_group_name,
+          security_group: security_group_name,
+          parameter_group: parameter_group_name
+        }
+      end
+
+      # Create ElastiCache cluster
+      # @param [String] app_name application name
+      # @param [String] cache_node_type instance node type
+      # @param [Integer] num_cache_nodes number of nodes to create
+      def elasticache_cluster_init(app_name, cache_node_type: 'cache.m1.small', num_cache_nodes: 1)
+        cluster_resources = init_cluster_resources(app_name, cache_node_type)
+
+        resource_name = "#{app_name}RedisCluster"
+        resource resource_name,
+                 Type: 'AWS::ElastiCache::CacheCluster',
+                 Properties: {
+                   Engine: 'redis',
+                   NumCacheNodes: "#{num_cache_nodes}",
+                   CacheNodeType: cache_node_type,
+                   CacheSubnetGroupName: ref("#{app_name}ElasticacheSubnetGroup"),
+                   CacheParameterGroupName: ref(cluster_resources[:parameter_group]),
+                   VpcSecurityGroupIds: [get_att("#{app_name}RedisSecurityGroup", 'GroupId')]
+                 }
+        resource_name
+
+        # Unable to get created resource endpoint and port with Fn::GetAtt for engine == redis
+        # For more details see here:
+        # http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-cache-cluster.html
+      end
+
+      # Create ElastiCache replication group
+      # @param [String] app_name application name
+      # @param [String] cache_node_type instance node type
+      def elasticache_repl_group_init(app_name, cache_node_type: 'cache.t2.small',
+                                      num_cache_clusters: 2, seed: nil, **properties)
+        if %w(t1).map { |t| cache_node_type.include?(t) }.include?(true)
+          fail "T1 instance types are not supported, got '#{cache_node_type}'"
+        end
+
+        cluster_properties =
+          !properties.nil? && properties.key?(:cluster_properties) ? properties[:cluster_properties] : {}
+
+        cluster_resources = init_cluster_resources(app_name,
+                                                   cache_node_type,
+                                                   param_group_seed: seed,
+                                                   parameter_group_properties: cluster_properties)
+
+        resource_name = "#{app_name}RedisReplicationGroup"
+        resource resource_name,
+                 Type: 'AWS::ElastiCache::ReplicationGroup',
+                 Properties: {
+                   Engine: 'redis',
+                   ReplicationGroupDescription: "Redis Replication group for #{app_name}",
+                   AutomaticFailoverEnabled: num_cache_clusters > 1 ? 'true' : 'false',
+                   NumCacheClusters: num_cache_clusters,
+                   CacheNodeType: cache_node_type,
+                   CacheSubnetGroupName: ref("#{app_name}ElasticacheSubnetGroup"),
+                   CacheParameterGroupName: ref(cluster_resources[:parameter_group]),
+                   SecurityGroupIds: [
+                     get_att("#{app_name}RedisSecurityGroup", 'GroupId'),
+                     ref_private_security_group
+                   ]
+                 }.merge(properties.reject { |k, _v| k == :cluster_properties })
+
+        output "#{app_name}RedisReplicationGroup",
+               Description: "Redis ReplicationGroup #{app_name}",
+               Value: ref("#{app_name}RedisReplicationGroup")
+
+        output "#{app_name}RedisPrimaryEndpointAddress",
+               Description: "Redis Primary Endpoint Address #{app_name}",
+               Value: get_att(resource_name, 'PrimaryEndPoint.Address')
+
+        output "#{app_name}RedisPrimaryEndpointPort",
+               Description: "Redis Primary Endpoint Port #{app_name}",
+               Value: get_att(resource_name, 'PrimaryEndPoint.Port')
+
+        output "#{app_name}RedisReadOnlyEndpointAddresses",
+               Description: "Redis ReadOnly Endpoint Addresses #{app_name}",
+               Value: get_att(resource_name, 'ReadEndPoint.Addresses')
+
+        output "#{app_name}RedisReadOnlyEndpointPorts",
+               Description: "Redis ReadOnly Endpoint Ports #{app_name}",
+               Value: get_att(resource_name, 'ReadEndPoint.Ports')
+
+        resource_name
+      end
+    end # module ElasticCache
+  end # module Plugins
+end # module Enscalator