Mini Shell
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
try:
import simplejson as json
except ImportError:
import json
from libcloud.container.base import (ContainerDriver, Container,
ContainerCluster, ContainerImage)
from libcloud.container.types import ContainerState
from libcloud.container.utils.docker import RegistryClient
from libcloud.common.aws import SignedAWSConnection, AWSJsonResponse
__all__ = [
'ElasticContainerDriver'
]
ECS_VERSION = '2014-11-13'
ECR_VERSION = '2015-09-21'
ECS_HOST = 'ecs.%s.amazonaws.com'
ECR_HOST = 'ecr.%s.amazonaws.com'
ROOT = '/'
ECS_TARGET_BASE = 'AmazonEC2ContainerServiceV%s' % \
(ECS_VERSION.replace('-', ''))
ECR_TARGET_BASE = 'AmazonEC2ContainerRegistry_V%s' % \
(ECR_VERSION.replace('-', ''))
class ECSJsonConnection(SignedAWSConnection):
version = ECS_VERSION
host = ECS_HOST
responseCls = AWSJsonResponse
service_name = 'ecs'
class ECRJsonConnection(SignedAWSConnection):
version = ECR_VERSION
host = ECR_HOST
responseCls = AWSJsonResponse
service_name = 'ecr'
class ElasticContainerDriver(ContainerDriver):
name = 'Amazon Elastic Container Service'
website = 'https://aws.amazon.com/ecs/details/'
ecr_repository_host = '%s.dkr.ecr.%s.amazonaws.com'
connectionCls = ECSJsonConnection
ecrConnectionClass = ECRJsonConnection
supports_clusters = False
status_map = {
'RUNNING': ContainerState.RUNNING
}
def __init__(self, access_id, secret, region):
super(ElasticContainerDriver, self).__init__(access_id, secret)
self.region = region
self.region_name = region
self.connection.host = ECS_HOST % (region)
# Setup another connection class for ECR
conn_kwargs = self._ex_connection_class_kwargs()
self.ecr_connection = self.ecrConnectionClass(
access_id, secret, **conn_kwargs)
self.ecr_connection.host = ECR_HOST % (region)
self.ecr_connection.driver = self
self.ecr_connection.connect()
def _ex_connection_class_kwargs(self):
return {'signature_version': '4'}
def list_images(self, ex_repository_name):
"""
List the images in an ECR repository
:param ex_repository_name: The name of the repository to check
defaults to the default repository.
:type ex_repository_name: ``str``
:return: a list of images
:rtype: ``list`` of :class:`libcloud.container.base.ContainerImage`
"""
request = {}
request['repositoryName'] = ex_repository_name
list_response = self.ecr_connection.request(
ROOT,
method='POST',
data=json.dumps(request),
headers=self._get_ecr_headers('ListImages')
).object
repository_id = self.ex_get_repository_id(ex_repository_name)
host = self._get_ecr_host(repository_id)
return self._to_images(list_response['imageIds'],
host,
ex_repository_name)
def list_clusters(self):
"""
Get a list of potential locations to deploy clusters into
:param location: The location to search in
:type location: :class:`libcloud.container.base.ClusterLocation`
:rtype: ``list`` of :class:`libcloud.container.base.ContainerCluster`
"""
listdata = self.connection.request(
ROOT,
method='POST',
data=json.dumps({}),
headers=self._get_headers('ListClusters')
).object
request = {'clusters': listdata['clusterArns']}
data = self.connection.request(
ROOT,
method='POST',
data=json.dumps(request),
headers=self._get_headers('DescribeClusters')
).object
return self._to_clusters(data)
def create_cluster(self, name, location=None):
"""
Create a container cluster
:param name: The name of the cluster
:type name: ``str``
:param location: The location to create the cluster in
:type location: :class:`libcloud.container.base.ClusterLocation`
:rtype: :class:`libcloud.container.base.ContainerCluster`
"""
request = {'clusterName': name}
response = self.connection.request(
ROOT,
method='POST',
data=json.dumps(request),
headers=self._get_headers('CreateCluster')
).object
return self._to_cluster(response['cluster'])
def destroy_cluster(self, cluster):
"""
Delete a cluster
:return: ``True`` if the destroy was successful, otherwise ``False``.
:rtype: ``bool``
"""
request = {'cluster': cluster.id}
data = self.connection.request(
ROOT,
method='POST',
data=json.dumps(request),
headers=self._get_headers('DeleteCluster')
).object
return data['cluster']['status'] == 'INACTIVE'
def list_containers(self, image=None, cluster=None):
"""
List the deployed container images
:param image: Filter to containers with a certain image
:type image: :class:`libcloud.container.base.ContainerImage`
:param cluster: Filter to containers in a cluster
:type cluster: :class:`libcloud.container.base.ContainerCluster`
:rtype: ``list`` of :class:`libcloud.container.base.Container`
"""
request = {'cluster': 'default'}
if cluster is not None:
request['cluster'] = cluster.id
if image is not None:
request['family'] = image.name
list_response = self.connection.request(
ROOT,
method='POST',
data=json.dumps(request),
headers=self._get_headers('ListTasks')
).object
if len(list_response['taskArns']) == 0:
return []
containers = self.ex_list_containers_for_task(
list_response['taskArns'])
return containers
def deploy_container(self, name, image, cluster=None,
parameters=None, start=True, ex_cpu=10, ex_memory=500,
ex_container_port=None, ex_host_port=None):
"""
Creates a task definition from a container image that can be run
in a cluster.
:param name: The name of the new container
:type name: ``str``
:param image: The container image to deploy
:type image: :class:`libcloud.container.base.ContainerImage`
:param cluster: The cluster to deploy to, None is default
:type cluster: :class:`libcloud.container.base.ContainerCluster`
:param parameters: Container Image parameters
:type parameters: ``str``
:param start: Start the container on deployment
:type start: ``bool``
:rtype: :class:`libcloud.container.base.Container`
"""
data = {}
if ex_container_port is None and ex_host_port is None:
port_maps = []
else:
port_maps = [
{
"containerPort": ex_container_port,
"hostPort": ex_host_port
}
]
data['containerDefinitions'] = [
{
"mountPoints": [],
"name": name,
"image": image.name,
"cpu": ex_cpu,
"environment": [],
"memory": ex_memory,
"portMappings": port_maps,
"essential": True,
"volumesFrom": []
}
]
data['family'] = name
response = self.connection.request(
ROOT,
method='POST',
data=json.dumps(data),
headers=self._get_headers('RegisterTaskDefinition')
).object
if start:
return self.ex_start_task(
response['taskDefinition']['taskDefinitionArn'])[0]
else:
return Container(
id=None,
name=name,
image=image,
state=ContainerState.RUNNING,
ip_addresses=[],
extra={
'taskDefinitionArn':
response['taskDefinition']['taskDefinitionArn']
},
driver=self.connection.driver
)
def get_container(self, id):
"""
Get a container by ID
:param id: The ID of the container to get
:type id: ``str``
:rtype: :class:`libcloud.container.base.Container`
"""
containers = self.ex_list_containers_for_task([id])
return containers[0]
def start_container(self, container, count=1):
"""
Start a deployed task
:param container: The container to start
:type container: :class:`libcloud.container.base.Container`
:param count: Number of containers to start
:type count: ``int``
:rtype: :class:`libcloud.container.base.Container`
"""
return self.ex_start_task(container.extra['taskDefinitionArn'], count)
def stop_container(self, container):
"""
Stop a deployed container
:param container: The container to stop
:type container: :class:`libcloud.container.base.Container`
:rtype: :class:`libcloud.container.base.Container`
"""
request = {'task': container.extra['taskArn']}
response = self.connection.request(
ROOT,
method='POST',
data=json.dumps(request),
headers=self._get_headers('StopTask')
).object
containers = []
containers.extend(self._to_containers(
response['task'],
container.extra['taskDefinitionArn']))
return containers
def restart_container(self, container):
"""
Restart a deployed container
:param container: The container to restart
:type container: :class:`libcloud.container.base.Container`
:rtype: :class:`libcloud.container.base.Container`
"""
self.stop_container(container)
return self.start_container(container)
def destroy_container(self, container):
"""
Destroy a deployed container
:param container: The container to destroy
:type container: :class:`libcloud.container.base.Container`
:rtype: :class:`libcloud.container.base.Container`
"""
return self.stop_container(container)
def ex_start_task(self, task_arn, count=1):
"""
Run a task definition and get the containers
:param task_arn: The task ARN to Run
:type task_arn: ``str``
:param count: The number of containers to start
:type count: ``int``
:rtype: ``list`` of :class:`libcloud.container.base.Container`
"""
request = None
request = {'count': count,
'taskDefinition': task_arn}
response = self.connection.request(
ROOT,
method='POST',
data=json.dumps(request),
headers=self._get_headers('RunTask')
).object
containers = []
for task in response['tasks']:
containers.extend(self._to_containers(task, task_arn))
return containers
def ex_list_containers_for_task(self, task_arns):
"""
Get a list of containers by ID collection (ARN)
:param task_arns: The list of ARNs
:type task_arns: ``list`` of ``str``
:rtype: ``list`` of :class:`libcloud.container.base.Container`
"""
describe_request = {'tasks': task_arns}
descripe_response = self.connection.request(
ROOT,
method='POST',
data=json.dumps(describe_request),
headers=self._get_headers('DescribeTasks')
).object
containers = []
for task in descripe_response['tasks']:
containers.extend(self._to_containers(
task, task['taskDefinitionArn']))
return containers
def ex_create_service(self, name, cluster,
task_definition, desired_count=1):
"""
Runs and maintains a desired number of tasks from a specified
task definition. If the number of tasks running in a service
drops below desired_count, Amazon ECS spawns another
instantiation of the task in the specified cluster.
:param name: the name of the service
:type name: ``str``
:param cluster: The cluster to run the service on
:type cluster: :class:`libcloud.container.base.ContainerCluster`
:param task_definition: The task definition name or ARN for the
service
:type task_definition: ``str``
:param desired_count: The desired number of tasks to be running
at any one time
:type desired_count: ``int``
:rtype: ``object`` The service object
"""
request = {
'serviceName': name,
'taskDefinition': task_definition,
'desiredCount': desired_count,
'cluster': cluster.id}
response = self.connection.request(
ROOT,
method='POST',
data=json.dumps(request),
headers=self._get_headers('CreateService')
).object
return response['service']
def ex_list_service_arns(self, cluster=None):
"""
List the services
:param cluster: The cluster hosting the services
:type cluster: :class:`libcloud.container.base.ContainerCluster`
:rtype: ``list`` of ``str``
"""
request = {}
if cluster is not None:
request['cluster'] = cluster.id
response = self.connection.request(
ROOT,
method='POST',
data=json.dumps(request),
headers=self._get_headers('ListServices')
).object
return response['serviceArns']
def ex_describe_service(self, service_arn):
"""
Get the details of a service
:param cluster: The hosting cluster
:type cluster: :class:`libcloud.container.base.ContainerCluster`
:param service_arn: The service ARN to describe
:type service_arn: ``str``
:return: The service object
:rtype: ``object``
"""
request = {'services': [service_arn]}
response = self.connection.request(
ROOT,
method='POST',
data=json.dumps(request),
headers=self._get_headers('DescribeServices')
).object
return response['services'][0]
def ex_destroy_service(self, service_arn):
"""
Deletes a service
:param cluster: The target cluster
:type cluster: :class:`libcloud.container.base.ContainerCluster`
:param service_arn: The service ARN to destroy
:type service_arn: ``str``
"""
request = {
'service': service_arn}
response = self.connection.request(
ROOT,
method='POST',
data=json.dumps(request),
headers=self._get_headers('DeleteService')
).object
return response['service']
def ex_get_registry_client(self, repository_name):
"""
Get a client for an ECR repository
:param repository_name: The unique name of the repository
:type repository_name: ``str``
:return: a docker registry API client
:rtype: :class:`libcloud.container.utils.docker.RegistryClient`
"""
repository_id = self.ex_get_repository_id(repository_name)
token = self.ex_get_repository_token(repository_id)
host = self._get_ecr_host(repository_id)
return RegistryClient(
host=host,
username='AWS',
password=token
)
def ex_get_repository_token(self, repository_id):
"""
Get the authorization token (12 hour expiry) for a repository
:param repository_id: The ID of the repository
:type repository_id: ``str``
:return: A token for login
:rtype: ``str``
"""
request = {'RegistryIds': [repository_id]}
response = self.ecr_connection.request(
ROOT,
method='POST',
data=json.dumps(request),
headers=self._get_ecr_headers('GetAuthorizationToken')
).object
return response['authorizationData'][0]['authorizationToken']
def ex_get_repository_id(self, repository_name):
"""
Get the ID of a repository
:param repository_name: The unique name of the repository
:type repository_name: ``str``
:return: The repository ID
:rtype: ``str``
"""
request = {'repositoryNames': [repository_name]}
list_response = self.ecr_connection.request(
ROOT,
method='POST',
data=json.dumps(request),
headers=self._get_ecr_headers('DescribeRepositories')
).object
repository_id = list_response['repositories'][0]['registryId']
return repository_id
def _get_ecr_host(self, repository_id):
return self.ecr_repository_host % (
repository_id,
self.region)
def _get_headers(self, action):
"""
Get the default headers for a request to the ECS API
"""
return {'x-amz-target': '%s.%s' %
(ECS_TARGET_BASE, action),
'Content-Type': 'application/x-amz-json-1.1'
}
def _get_ecr_headers(self, action):
"""
Get the default headers for a request to the ECR API
"""
return {'x-amz-target': '%s.%s' %
(ECR_TARGET_BASE, action),
'Content-Type': 'application/x-amz-json-1.1'
}
def _to_clusters(self, data):
clusters = []
for cluster in data['clusters']:
clusters.append(self._to_cluster(cluster))
return clusters
def _to_cluster(self, data):
return ContainerCluster(
id=data['clusterArn'],
name=data['clusterName'],
driver=self.connection.driver
)
def _to_containers(self, data, task_definition_arn):
clusters = []
for cluster in data['containers']:
clusters.append(self._to_container(cluster, task_definition_arn))
return clusters
def _to_container(self, data, task_definition_arn):
return Container(
id=data['containerArn'],
name=data['name'],
image=ContainerImage(
id=None,
name=data['name'],
path=None,
version=None,
driver=self.connection.driver
),
ip_addresses=None,
state=self.status_map.get(data['lastStatus'], None),
extra={
'taskArn': data['taskArn'],
'taskDefinitionArn': task_definition_arn
},
driver=self.connection.driver
)
def _to_images(self, data, host, repository_name):
images = []
for image in data:
images.append(self._to_image(image, host, repository_name))
return images
def _to_image(self, data, host, repository_name):
path = '%s/%s:%s' % (
host,
repository_name,
data['imageTag']
)
return ContainerImage(
id=None,
name=path,
path=path,
version=data['imageTag'],
driver=self.connection.driver
)
Zerion Mini Shell 1.0