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())