Class: Kontena::Machine::Aws::MasterProvisioner

Inherits:
Object
  • Object
show all
Includes:
Cli::Common, Common, CertHelper, RandomName
Defined in:
lib/kontena/machine/aws/master_provisioner.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Common

#default_subnet, #default_vpc, #resolve_ami, #resolve_security_groups_to_ids

Constructor Details

#initialize(access_key_id, secret_key, region) ⇒ MasterProvisioner

Returns a new instance of MasterProvisioner.

Parameters:

  • access_key_id (String) —

    aws_access_key_id

  • secret_key (String) —

    aws_secret_access_key

  • region (String) 


21
22
23
24
25
 
# File 'lib/kontena/machine/aws/master_provisioner.rb', line 21

def initialize(access_key_id, secret_key, region)
  @ec2 = ::Aws::EC2::Resource.new(
    region: region, credentials: ::Aws::Credentials.new(access_key_id, secret_key)
  )
end

Instance Attribute Details

#ec2 ⇒ Object (readonly)

Returns the value of attribute ec2.



16
17
18
 
# File 'lib/kontena/machine/aws/master_provisioner.rb', line 16

def ec2
  @ec2
end

#http_client ⇒ Object (readonly)

Returns the value of attribute http_client.



16
17
18
 
# File 'lib/kontena/machine/aws/master_provisioner.rb', line 16

def http_client
  @http_client
end

#region ⇒ String (readonly)

Returns:

  • (String) 


178
179
180
 
# File 'lib/kontena/machine/aws/master_provisioner.rb', line 178

def region
  @region
end

Instance Method Details

#create_security_group(name, vpc_id = nil) ⇒ Object

creates security_group and authorizes default port ranges

Parameters:

  • name (String)
  • vpc_id (String, NilClass) (defaults to: nil)

Returns:

  • Aws::EC2::SecurityGroup



153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
 
# File 'lib/kontena/machine/aws/master_provisioner.rb', line 153

def create_security_group(name, vpc_id = nil)
  sg = ec2.create_security_group({
    group_name: name,
    description: "Kontena Master",
    vpc_id: vpc_id
  })

  sg.authorize_ingress({
    ip_protocol: 'tcp',
    from_port: 443,
    to_port: 443,
    cidr_ip: '0.0.0.0/0'
  })

  sg.authorize_ingress({
    ip_protocol: 'tcp',
    from_port: 22,
    to_port: 22,
    cidr_ip: '0.0.0.0/0'
  })

  sg
end

#ensure_security_group(vpc_id) ⇒ Array

Returns Security group id in array.

Parameters:

  • vpc_id (String)

Returns:

  • (Array) —

    Security group id in array



134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/kontena/machine/aws/master_provisioner.rb', line 134

def ensure_security_group(vpc_id)
  group_name = "kontena_master"
  group_id = resolve_security_groups_to_ids(group_name, vpc_id)

  if group_id.empty?
     "Creating AWS security group" do
      sg = create_security_group(group_name, vpc_id)
      group_id = [sg.group_id]
    end
  end
  group_id
end

#erb(template, vars) ⇒ Object 



197
198
199
200
201
 
# File 'lib/kontena/machine/aws/master_provisioner.rb', line 197

def erb(template, vars)
  ERB.new(template, nil, '%<>-').result(
    OpenStruct.new(vars).instance_eval { binding }
  )
end

#generate_name ⇒ Object 



187
188
189
 
# File 'lib/kontena/machine/aws/master_provisioner.rb', line 187

def generate_name
  "kontena-master-#{super}-#{rand(1..9)}"
end

#master_running?(http_client) ⇒ Boolean

Returns:

  • (Boolean) 


191
192
193
194
195
 
# File 'lib/kontena/machine/aws/master_provisioner.rb', line 191

def master_running?(http_client)
  http_client.get(path: '/').status == 200
rescue
  false
end

#run!(opts) ⇒ Object

Parameters:

  • opts (Hash) 


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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/kontena/machine/aws/master_provisioner.rb', line 28

def run!(opts)
  ssl_cert = nil
  if opts[:ssl_cert]
    abort('Invalid ssl cert') unless File.exists?(File.expand_path(opts[:ssl_cert]))
    ssl_cert = File.read(File.expand_path(opts[:ssl_cert]))
  else
     "Generating a self-signed SSL certificate" do
      ssl_cert = generate_self_signed_cert
    end
  end

  if opts[:ami]
    ami = opts[:ami]
  else
    ami = resolve_ami(region)
    abort('No valid AMI found for region') unless ami
  end
  opts[:vpc] = default_vpc.vpc_id unless opts[:vpc]

  raise "Missing :subnet option" if opts[:subnet].nil?
  subnet = ec2.subnet(opts[:subnet])
  abort('Failed to find subnet!') unless subnet

  name = opts[:name] || generate_name

  userdata_vars = opts.merge(
      ssl_cert: ssl_cert,
      server_name: name.sub('kontena-master-', '')
  )

  security_groups = opts[:security_groups] ?
      resolve_security_groups_to_ids(opts[:security_groups], opts[:vpc]) :
      ensure_security_group(opts[:vpc])

  ec2_instance = ec2.create_instances({
    image_id: ami,
    min_count: 1,
    max_count: 1,
    instance_type: opts[:type],
    key_name: opts[:key_pair],
    user_data: Base64.encode64(user_data(userdata_vars)),
    block_device_mappings: [
      {
        device_name: '/dev/xvda',
        virtual_name: 'Root',
        ebs: {
          volume_size: opts[:storage],
          volume_type: 'gp2'
        }
      }
    ],
    network_interfaces: [
     {
       device_index: 0,
       subnet_id: subnet.subnet_id,
       groups: security_groups,
       associate_public_ip_address: opts[:associate_public_ip],
       delete_on_termination: true
     }
    ]
  }).first
  ec2_instance.create_tags({
    tags: [
      {key: 'Name', value: name}
    ]
  })

   "Creating an AWS instance #{name.colorize(:cyan)} " do
    sleep 1 until ec2_instance.reload.state.name == 'running'
  end
  public_ip = ec2_instance.reload.public_ip_address
  master_version = nil
  if public_ip.nil?
    master_url = "https://#{ec2_instance.private_ip_address}"
    puts "Could not get public IP for the created master, private connect url is: #{master_url}"
  else
    master_url = "https://#{ec2_instance.public_ip_address}"
    Excon.defaults[:ssl_verify_peer] = false
    http_client = Excon.new(master_url, :connect_timeout => 10)
     "Waiting for #{name.colorize(:cyan)} to start " do
      sleep 0.5 until master_running?(http_client)
    end

     "Retrieving Kontena Master version" do
      master_version = JSON.parse(http_client.get(path: '/').body)["version"] rescue nil
    end

     "Kontena Master #{master_version} is now running at #{master_url}"
  end
  data = {
    name: name.sub('kontena-master-', ''),
    public_ip: public_ip,
    code: opts[:initial_admin_code],
    provider: 'aws',
    version: master_version
  }
  if self.respond_to?(:certificate_public_key)
    data[:ssl_certificate] = certificate_public_key(ssl_cert) unless opts[:ssl_cert]
  end

  data
end

#user_data(vars) ⇒ Object 



182
183
184
185
 
# File 'lib/kontena/machine/aws/master_provisioner.rb', line 182

def user_data(vars)
  cloudinit_template = File.join(__dir__ , '/cloudinit_master.yml')
  erb(File.read(cloudinit_template), vars)
end