def create_load_balancer():
# Compute driver to retrieve servers to be pool members (the nodes)
cls = libcloud.get_driver(libcloud.DriverType.COMPUTE,
libcloud.DriverType.COMPUTE.NTTCIS)
compute_driver = cls('my_username', 'my_pass', region='eu')
net_domain_name = 'sdk_test_1'
net_domains = compute_driver.ex_list_network_domains(location='EU6')
net_domain_id = [d for d in net_domains if d.name == net_domain_name][0].id
# Load balancer driver to create and/or edit load balanceers
cls = libcloud.get_driver(libcloud.DriverType.LOADBALANCER,
libcloud.DriverType.LOADBALANCER.NTTCIS)
lbdriver = cls('my_username', net_domain_id, 'my_pass', region='eu')
member1 = compute_driver.list_nodes(ex_name='web1')[0]
member2 = compute_driver.list_nodes(ex_name='web2')[0]
members = [member1, member2]
name = 'sdk_test_balancer'
port = '80'
listener_port = '8000'
protocol = 'TCP'
algorithm = Algorithm.LEAST_CONNECTIONS_MEMBER
members = [m for m in members]
ex_listener_ip_address = "168.128.13.127"
lb = lbdriver.create_balancer(
name,
listener_port=listener_port,
port=port,
protocol=protocol,
algorithm=algorithm,
members=members,
optimization_profile='TCP',
ex_listener_ip_address=ex_listener_ip_address)
print(lb)
def get_cloud_object_as_io(cls, container_name, object_name):
provider = settings.CLOUD_BROWSER_APACHE_LIBCLOUD_PROVIDER.lower()
account = settings.CLOUD_BROWSER_APACHE_LIBCLOUD_ACCOUNT
key = settings.CLOUD_BROWSER_APACHE_LIBCLOUD_SECRET_KEY
driver = get_driver(DriverType.STORAGE, provider)
client = driver(account, key)
cloud_container = client.get_container(container_name)
cloud_object = cloud_container.get_object(object_name)
return iterable_to_io(cloud_object.as_stream())
def _get_driver_method(self, func):
cls = libcloud.get_driver(libcloud.DriverType.COMPUTE, self.provider)
ins = cls(self.username, self.api_key, **self.ex)
extend = extendDriver.get(self.provider)
if hasattr(ins, func):
pass
elif hasattr(extend, func):
method = getattr(extend, func)
setattr(ins, func, MethodType(method, ins))
else:
raise Exception('invalid method "%s" in the driver "%s"' %
(func, cls.__class__))
return getattr(ins, func)
def __init__(self, provider_name=None):
"""Establish the connection.
__init__ establish the connection with the provider and connect to the bucket.
Parameters
----------
provider_name : string
it should be the configuration key which is defined in the settings file
Returns
-------
None
It updated the object connection parameter
Raises
------
ImproperlyConfigured
When the configuration is not proper
Examples
--------
>>> s=Storage('default')
"""
# check if the provider name is in the list or none
if provider_name is not None:
# build the provider dict
self.provider = settings.STORAGE_PROVIDERS[provider_name]
try:
# load the connection driver
cls = libcloud.get_driver(libcloud.DriverType.STORAGE,
provider_mapper[self.provider['type']])
except Exception as e:
# if connection driver is not found, raise an expection
raise ImproperlyConfigured(
"Unable to find libcloud driver type %s: %s" %
(provider_mapper[self.provider['type']], e))
try:
# make the connection with the platform, pass the username and secret
self.driver = cls(key=self.provider['user'],
secret=self.provider['secret'])
# connect to the bucket, only one bucket connection is allowed per connection
self.bucket = self.driver.get_container(self.provider['bucket'])
except Exception as e:
# if connection to bucket is not established then raise an expection
raise ImproperlyConfigured(
"Unable to create libcloud driver type %s: %s" %
(provider_mapper[self.provider['type']], e))
def __init__(self, deployment, logger=None):
Provisioner.__init__(self, deployment, logger)
self.logger.info("Configuring")
self.name = self.deployment.name
self.gce = self.deployment['gce']
self.credentials = json.load(open(self.gce['account'], 'r'))
args = [
self.credentials['client_email'], self.credentials['private_key']
]
kwargs = {
'project':
self.gce['project'],
'datacenter':
self.gce['zone'],
'credential_file':
os.path.join(os.path.curdir, 'openshifter', self.name,
'credentials.cache')
}
self.logger.info("Setting up")
driver = libcloud.get_driver(libcloud.DriverType.COMPUTE,
libcloud.DriverType.COMPUTE.GCE)
self.compute = driver(*args, **kwargs)
self.logger.info("Getting disk image")
if self.deployment['type'] == 'ocp':
self.disk_image = self.compute.ex_get_image('rhel-7')
else:
self.disk_image = self.compute.ex_get_image('centos-7')
self.logger.info("Validating Zone and Region")
try:
self.zone = self.compute.ex_get_zone(self.gce['zone'])
except ResourceNotFoundError:
self.zone = None
try:
self.region = self.compute.ex_get_region(self.gce['region'])
except ResourceNotFoundError:
self.region = None
if self.zone is None:
self.logger.error("Zone is invalid")
sys.exit(1)
if self.region is None:
self.logger.error("Region is invalid")
sys.exit(1)
from pprint import pprint
import libcloud
cls = libcloud.get_driver(
libcloud.DriverType.COMPUTE, libcloud.DriverType.COMPUTE.CLOUDSCALE
)
TOKEN = "3pjzjh3h3rfynqa4iemvtvc33pyfzss2"
driver = cls(TOKEN)
sizes = driver.list_sizes()
images = driver.list_images()
pprint(sizes)
pprint(images)
new_node = driver.create_node(
name="hello-darkness-my-old-friend",
size=sizes[0],
image=images[0],
ex_create_attr=dict(
ssh_keys=["ssh-rsa AAAAB3Nza..."],
use_private_network=True,
),
)
pprint(new_node)
def compute_driver():
cls = libcloud.get_driver(libcloud.DriverType.COMPUTE,
libcloud.DriverType.COMPUTE.NTTCIS)
driver = cls("mitchgeo-test", "Snmpv2c!", region="eu")
return driver
def lbdriver():
cls = libcloud.get_driver(libcloud.DriverType.LOADBALANCER,
libcloud.DriverType.LOADBALANCER.NTTCIS)
driver = cls("mitchgeo-test", "Snmpv2c!", region="eu")
return driver
def lbdriver():
cls = libcloud.get_driver(libcloud.DriverType.LOADBALANCER,
libcloud.DriverType.LOADBALANCER.NTTCIS)
driver = cls('mitchgeo-test', 'Snmpv2c!', region='eu')
return driver
def _get_connection(self):
"""Return native connection object."""
driver = libcloud.get_driver(libcloud.DriverType.STORAGE, self.provider.lower())
return driver(self.account, self.secret_key)
def test_factory(self):
driver = libcloud.get_driver(libcloud.DriverType.COMPUTE,
libcloud.DriverType.COMPUTE.EC2)
self.assertEqual(driver.__name__, 'EC2NodeDriver')
def _get_driver(self):
cls = libcloud.get_driver(libcloud.DriverType.COMPUTE, self.provider)
return extendDriver.get(cls.__class__, cls)(self.username,
self.api_key, **self.ex)
from pprint import pprint
import libcloud
cls = libcloud.get_driver(
libcloud.DriverType.COMPUTE,
libcloud.DriverType.COMPUTE.CLOUDSCALE
)
TOKEN = '3pjzjh3h3rfynqa4iemvtvc33pyfzss2'
driver = cls(TOKEN)
sizes = driver.list_sizes()
images = driver.list_images()
pprint(sizes)
pprint(images)
new_node = driver.create_node(
name='hello-darkness-my-old-friend',
size=sizes[0],
image=images[0],
ex_create_attr=dict(
ssh_keys=['ssh-rsa AAAAB3Nza...'],
use_private_network=True,
)
)
pprint(new_node)
def _get_driver_class(self) -> typing.Type[NodeDriver]:
"""Returns the libcloud driver class for the id of this adapter."""
return libcloud.get_driver(libcloud.DriverType.COMPUTE, self._get_id())
def run(self):
# Spawn EC2 Instance
if self.debug:
print("Debug network runner ran")
return
# spawn a new ec2/GPU instance with libcloud
cls = get_driver(type=DriverType.COMPUTE, provider=ProviderCompute.EC2)
IMAGE_ID = 'ami-6d95db0d'
# https://aws.amazon.com/marketplace/fulfillment?productId=0ce7aca3-5b96-4ff4-8396-05245687380a&ref_=dtl_psb_continue®ion=us-east-1
SIZE_ID = 'g2.2xlarge'
KEYPAIR_NAME = 'spawn-gpu'
aws_access = os.environ.get('AWS_ACCESS', 'default_aws_access')
aws_secret = os.environ.get('AWS_SECRET', 'default_aws_secret')
driver = cls(key=aws_access, secret=aws_secret, region="us-west-1")
sizes = driver.list_sizes()
images = driver.list_images()
size = [s for s in sizes if s.id == SIZE_ID][0]
image = [i for i in images if i.id == IMAGE_ID][0]
node = driver.create_node(name='test-node',
image=image,
size=size,
ex_keyname=KEYPAIR_NAME)
ip = driver.wait_until_running(nodes=[node])
# connect to that new instance
public_ip = ip[0][1][0]
k = paramiko.RSAKey.from_private_key_file(
"/Users/apple/Downloads/spawn-gpu.pem")
c = paramiko.SSHClient()
c.set_missing_host_key_policy(paramiko.AutoAddPolicy())
wait_count = 10
while True:
try:
c.connect(hostname=public_ip, username='******', pkey=k)
break
except Exception:
time.sleep(10)
wait_count -= 1
if wait_count == 0:
raise Exception("Can't connect to Remote GPU")
pass
run_obj = self._generate_cmd()
# docker run -it customer1/user1 /usr/bin/python3 /run_object.py -o ObjectA
pull_docker = 'sudo docker pull emmjaykay/customer1.user'
# execute the result
cmds = [
'sudo yum install docker -y', 'sudo /etc/init.d/docker start',
'sudo docker pull emmjaykay/customer1.user',
'sudo docker run -it emmjaykay/customer1.user ' + run_obj
]
for cmd in cmds:
stdin, stdout, stderr = c.exec_command(cmd, get_pty=True)
print(stdout.read())
# collect result
# Should be collected in to an S3 bucket of somekind somewhere
# destroy node
driver.destroy_node(node)
return
def compute_driver():
cls = libcloud.get_driver(libcloud.DriverType.COMPUTE,
libcloud.DriverType.COMPUTE.NTTCIS)
driver = cls('mitchgeo-test', 'Snmpv2c!', region='eu')
return driver
def update_health_monitors(driver, network_domain, monitor_id):
pool_name = "sdk_test_balancer"
pools = driver.ex_get_pools(ex_network_domain_id=network_domain.id)
pool = [p for p in pools if p.name == pool_name][0]
pool.health_monitor_id = monitor_id
result = lbdriver.ex_update_pool(pool)
return result
def health_monitors(driver, network_domain):
monitors = driver.ex_get_default_health_monitors(network_domain)
return monitors
# Compute driver to create/edit virtual servers
cls = libcloud.get_driver(libcloud.DriverType.COMPUTE,
libcloud.DriverType.COMPUTE.NTTCIS)
compute_driver = cls("my_username", "my_pass", region="eu")
# Load balancer driver to create and/or edit load balanceers
cls = libcloud.get_driver(libcloud.DriverType.LOADBALANCER,
libcloud.DriverType.LOADBALANCER.NTTCIS)
net_domain_name = "sdk_test_1"
net_domains = compute_driver.ex_list_network_domains(location="EU6")
net_domain_id = [d for d in net_domains if d.name == net_domain_name][0].id
lbdriver = cls("my_username", net_domain_id, "my_pass", region="eu")
# Get available health monitors
results = health_monitors(lbdriver, net_domains[0])
for result in results:
print(result)
def __connect(self):
parts = urlparse(self.__config.url)
driver = libcloud.get_driver(libcloud.DriverType.STORAGE, parts.scheme)
service = driver(self.__config.key, self.__config.secret)
self.__bucket = service.get_container(parts.hostname)
def test_raises_error(self):
with self.assertRaises(DriverTypeNotFoundError):
libcloud.get_driver('potato', 'potato')
from pprint import pprint
import libcloud
import configparser, os
cls = libcloud.get_driver(libcloud.DriverType.COMPUTE,
libcloud.DriverType.COMPUTE.EC2)
config = configparser.ConfigParser()
config.read(os.getenv('HOME') + '/.aws/config')
key = config['default']['aws_access_key_id']
secret = config['default']['aws_secret_access_key']
region = config['default']['region']
driver = cls(key, secret, region=region)
sizes = driver.list_sizes()
images = driver.list_images()
SIZE = 't2.small'
IMAGE = 'ami-0155c31ea13d4abd2'
size = [s for s in sizes if s.id == SIZE][0]
image = [i for i in images if i.id == IMAGE][0]
node = driver.create_node(name='test-node', image=image, size=size)
#pprint(driver.list_sizes())
pprint(driver.list_nodes())
