def _get_driver(profile): config = __salt__['config.option']('libcloud_loadbalancer')[profile] cls = get_driver(config['driver']) args = config del args['driver'] args['key'] = config.get('key') args['secret'] = config.get('secret', None) args['secure'] = config.get('secure', True) args['host'] = config.get('host', None) args['port'] = config.get('port', None) return cls(**args)
def _get_driver(profile): config = __salt__["config.option"]("libcloud_loadbalancer")[profile] cls = get_driver(config["driver"]) args = config.copy() del args["driver"] args["key"] = config.get("key") args["secret"] = config.get("secret", None) if args["secret"] is None: del args["secret"] args["secure"] = config.get("secure", True) args["host"] = config.get("host", None) args["port"] = config.get("port", None) return cls(**args)
def test_user_must_provide_host_and_path(self): CloudStackLBDriver.path = None CloudStackLBDriver.type = Provider.CLOUDSTACK expected_msg = 'When instantiating CloudStack driver directly ' + \ 'you also need to provide host and path argument' cls = get_driver(Provider.CLOUDSTACK) assertRaisesRegex(self, Exception, expected_msg, cls, 'key', 'secret') try: cls('key', 'secret', True, 'localhost', '/path') except Exception: self.fail('host and path provided but driver raised an exception')
def test_user_must_provide_host_and_path(self): CloudStackLBDriver.path = None CloudStackLBDriver.type = Provider.CLOUDSTACK expected_msg = ("When instantiating CloudStack driver directly " + "you also need to provide host and path argument") cls = get_driver(Provider.CLOUDSTACK) assertRaisesRegex(self, Exception, expected_msg, cls, "key", "secret") try: cls("key", "secret", True, "localhost", "/path") except Exception: self.fail("host and path provided but driver raised an exception")
def test_user_must_provide_host_and_path(self): CloudStackLBDriver.path = None CloudStackLBDriver.type = Provider.CLOUDSTACK expected_msg = 'When instantiating CloudStack driver directly ' + \ 'you also need to provide host and path argument' cls = get_driver(Provider.CLOUDSTACK) self.assertRaisesRegexp(Exception, expected_msg, cls, 'key', 'secret') try: cls('key', 'secret', True, 'localhost', '/path') except Exception: self.fail('host and path provided but driver raised an exception')
def main(): cls = get_driver(Provider.ELB) driver = cls(key=ACCESS_ID, secret=SECRET_KEY) print(driver.list_balancers()) # members associated with the load balancer members = (Member(None, "192.168.88.1", 8000), Member(None, "192.168.88.2", 8080)) # creates a new balancer named 'MyLB' new_balancer = driver.create_balancer( name="MyLB", algorithm=Algorithm.ROUND_ROBIN, port=80, protocol="http", members=members, ) print(new_balancer) # create load balancer policy print( driver.ex_create_balancer_policy( name="MyLB", policy_name="EnableProxyProtocol", policy_type="ProxyProtocolPolicyType", policy_attributes={"ProxyProtocol": "true"}, )) # delete load balancer policy print( driver.ex_delete_balancer_policy(name="MyLB", policy_name="EnableProxyProtocol")) # set load balancer policies for backend server print( driver.ex_set_balancer_policies_backend_server( name="MyLB", port=80, policies=["MyDurationStickyPolicy"])) # create the listeners for the balancers uid = "arn:aws:iam::123456789012:server-certificate/servercert" print( driver.ex_create_balancer_listeners( name="MyLB", listeners=[[1024, 65533, "HTTPS", uid]])) # set the listeners policies for the balancers print( driver.ex_set_balancer_policies_listener( name="MyLB", port=80, policies=["MyDurationStickyPolicy"]))
def main(): cls = get_driver(Provider.ELB) driver = cls(key=ACCESS_ID, secret=SECRET_KEY) print(driver.list_balancers()) # members associated with the load balancer members = (Member(None, '192.168.88.1', 8000), Member(None, '192.168.88.2', 8080)) # creates a new balancer named 'MyLB' new_balancer = driver.create_balancer( name='MyLB', algorithm=Algorithm.ROUND_ROBIN, port=80, protocol='http', members=members) print(new_balancer) # create load balancer policy print driver.ex_create_balancer_policy( name='MyLB', policy_name='EnableProxyProtocol', policy_type='ProxyProtocolPolicyType', policy_attributes={'ProxyProtocol': 'true'}) # delete load balancer policy print driver.ex_delete_balancer_policy( name='MyLB', policy_name='EnableProxyProtocol') # set load balancer policies for backend server print driver.ex_set_balancer_policies_backend_server( name='MyLB', port=80, policies=['MyDurationStickyPolicy']) # create the listeners for the balancers print driver.ex_create_balancer_listeners( name='MyLB', listeners=[[1024, 65533, 'HTTPS', 'arn:aws:iam::123456789012:server-certificate/servercert']]) # set the listeners policies for the balancers print driver.ex_set_balancer_policies_listener( name='MyLB', port=80, policies=['MyDurationStickyPolicy'])
def main(): cls = get_driver(Provider.ELB) driver = cls(key=ACCESS_ID, secret=SECRET_KEY) print(driver.list_balancers()) # members associated with the load balancer members = (Member(None, '192.168.88.1', 8000), Member(None, '192.168.88.2', 8080)) # creates a new balancer named 'MyLB' new_balancer = driver.create_balancer(name='MyLB', algorithm=Algorithm.ROUND_ROBIN, port=80, protocol='http', members=members) print(new_balancer) # create load balancer policy print( driver.ex_create_balancer_policy( name='MyLB', policy_name='EnableProxyProtocol', policy_type='ProxyProtocolPolicyType', policy_attributes={'ProxyProtocol': 'true'})) # delete load balancer policy print( driver.ex_delete_balancer_policy(name='MyLB', policy_name='EnableProxyProtocol')) # set load balancer policies for backend server print( driver.ex_set_balancer_policies_backend_server( name='MyLB', port=80, policies=['MyDurationStickyPolicy'])) # create the listeners for the balancers uid = 'arn:aws:iam::123456789012:server-certificate/servercert' print( driver.ex_create_balancer_listeners( name='MyLB', listeners=[[1024, 65533, 'HTTPS', uid]])) # set the listeners policies for the balancers print( driver.ex_set_balancer_policies_listener( name='MyLB', port=80, policies=['MyDurationStickyPolicy']))
def main(): cls = get_driver(Provider.RACKSPACE) driver = cls("username", "api key", region="ord") balancers = driver.list_balancers() print(balancers) # creating a balancer which balances traffic across two # nodes: 192.168.86.1:80 and 192.168.86.2:8080. Balancer # itself listens on port 80/tcp new_balancer_name = "testlb" + os.urandom(4).encode("hex") members = (Member(None, "192.168.86.1", 80), Member(None, "192.168.86.2", 8080)) new_balancer = driver.create_balancer( name=new_balancer_name, algorithm=Algorithm.ROUND_ROBIN, port=80, protocol="http", members=members, ) print(new_balancer) # wait for balancer to become ready # NOTE: in real life code add timeout to not end up in # endless loop when things go wrong on provider side while True: balancer = driver.get_balancer(balancer_id=new_balancer.id) if balancer.state == State.RUNNING: break print("sleeping for 30 seconds for balancers to become ready") time.sleep(30) # fetch list of members members = balancer.list_members() print(members) # remove first member balancer.detach_member(members[0]) # remove the balancer driver.destroy_balancer(new_balancer)
def main(): Rackspace = get_driver(Provider.RACKSPACE_US) driver = Rackspace('username', 'api key') balancers = driver.list_balancers() print(balancers) # creating a balancer which balances traffic across two # nodes: 192.168.86.1:80 and 192.168.86.2:8080. Balancer # itself listens on port 80/tcp new_balancer_name = 'testlb' + os.urandom(4).encode('hex') members = (Member(None, '192.168.86.1', 80), Member(None, '192.168.86.2', 8080)) new_balancer = driver.create_balancer(name=new_balancer_name, algorithm=Algorithm.ROUND_ROBIN, port=80, protocol='http', members=members) print(new_balancer) # wait for balancer to become ready # NOTE: in real life code add timeout to not end up in # endless loop when things go wrong on provider side while True: balancer = driver.get_balancer(balancer_id=new_balancer.id) if balancer.state == State.RUNNING: break print('sleeping for 30 seconds for balancers to become ready') time.sleep(30) # fetch list of members members = balancer.list_members() print(members) # remove first member balancer.detach_member(members[0]) # remove the balancer driver.destroy_balancer(new_balancer)
def main(): Rackspace = get_driver(Provider.RACKSPACE_US) driver = Rackspace('username', 'api key') balancers = driver.list_balancers() print(balancers) # creating a balancer which balances traffic across two # nodes: 192.168.86.1:80 and 192.168.86.2:8080. Balancer # itself listens on port 80/tcp new_balancer_name = 'testlb' + os.urandom(4).encode('hex') members = (Member(None, '192.168.86.1', 80), Member(None, '192.168.86.2', 8080)) new_balancer = driver.create_balancer(name=new_balancer_name, algorithm=Algorithm.ROUND_ROBIN, port=80, protocol='http', members) print(new_balancer) # wait for balancer to become ready # NOTE: in real life code add timeout to not end up in # endless loop when things go wrong on provider side while True: balancer = driver.get_balancer(balancer_id=new_balancer.id) if balancer.state == State.RUNNING: break print('sleeping for 30 seconds for balancers to become ready') time.sleep(30) # fetch list of members members = balancer.list_members() print(members) # remove first member balancer.detach_member(members[0]) # remove the balancer driver.destroy_balancer(new_balancer)
def get_client(parsed_args, driver_kwargs=None): config = get_config() # TODO: regions/uk driver = get_driver(Provider.RACKSPACE_US) username = config['username'] api_key = config['api_key'] if parsed_args.username: username = parsed_args.username if parsed_args.api_key: api_key = parsed_args.api_key api_url = parsed_args.api_url auth_url = parsed_args.auth_url if not username: raise ValueError('Missing required argument: username') if not api_key: raise ValueError('Missing required argument: api-key') if driver_kwargs: options = driver_kwargs.copy() else: options = {} if api_url is not None: options['ex_force_base_url'] = api_url if auth_url is not None: options['ex_force_auth_url'] = auth_url if parsed_args.region is not None: options['ex_force_region'] = parsed_args.region return driver(username, api_key, **options)
def test_driver_instantiation(self): cls = get_driver(Provider.NINEFOLD) cls('username', 'key')
from libcloud.compute.base import NodeLocation from libcloud.loadbalancer.types import Provider from libcloud.loadbalancer.providers import get_driver USER_NAME = 'your user name' SECRET_KEY = 'your secret key' cls = get_driver(Provider.SOFTLAYER) driver = cls(key=USER_NAME, secret=SECRET_KEY) # order loadbalancer with a capacity of 50 connections CAPACITY = 50 # create the balancer in Dallas 5 datacenter DATACENTER = 'dal05' # select package to create balancer from packages = driver.ex_list_balancer_packages() lb_package = [p for p in packages if p.capacity == CAPACITY][0] driver.ex_place_balancer_order(lb_package, NodeLocation(DATACENTER, None, None, None)) print('Successfully submitted oder request, from package %s' % (lb_package))
def test_driver_instantiation(self): cls = get_driver(Provider.NINEFOLD) cls("username", "key")
# # 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. from libcloud.compute.types import Provider as NodeProvider from libcloud.compute.providers import get_driver as get_node_driver from libcloud.loadbalancer.providers import get_driver from libcloud.loadbalancer.base import Algorithm, Member from libcloud.loadbalancer.types import Provider SLBDriver = get_driver(Provider.ALIYUN_SLB) ECSDriver = get_node_driver(NodeProvider.ALIYUN_ECS) region = 'cn-hangzhou' your_access_key_id = '' your_access_key_secret = '' slb = SLBDriver(your_access_key_id, your_access_key_secret, region=region) ecs = ECSDriver(your_access_key_id, your_access_key_secret, region=region) protos = slb.list_protocols() print('Found %d protocols: %s' % (len(protos), protos)) balancers = slb.list_balancers() print('Found %d load balancers' % len(balancers)) print(balancers)
import os from argparse import ArgumentParser import libcloud.security from libcloud.common.types import LibcloudError from libcloud.loadbalancer.base import Member, Algorithm from libcloud.loadbalancer.types import Provider from libcloud.loadbalancer.providers import get_driver libcloud.security.VERIFY_SSL_CERT = False Driver = get_driver(Provider.RACKSPACE) USERNAME = os.environ.get('RS_USERNAME') APIKEY = os.environ.get('RS_APIKEY') def get_all_lbs(region=None): if not region: regions = [ 'iad', 'dfw', 'ord', 'syd', 'hkg', ] else: regions = [region] lbs = [] for r in regions:
def openqrm_lc_get_connection(params): Driver = get_driver(Provider.ELB)(params['ACCESS_ID'], params['SECRET_KEY'], params['REGION']) return Driver
import libcloud.security libcloud.security.CA_CERTS_PATH.append('/app/cacert.pem') from libcloud.loadbalancer.base import Member, Algorithm from libcloud.loadbalancer.types import State, Provider from libcloud.loadbalancer.providers import get_driver import time import json import sys import os from urlparse import urlsplit import requests from config import config driver = get_driver(Provider.RACKSPACE_US)(config['rackspace_user'], config['rackspace_api_key']) ETCD_WATCH_VALUE=os.environ['ETCD_WATCH_VALUE'] ETCD_WATCH_KEY=os.environ['ETCD_WATCH_KEY'] ETCD_WATCH_MODIFIED_INDEX=os.environ['ETCD_WATCH_MODIFIED_INDEX'] def acquire_lock(ttl=5): r = requests.post('http://172.17.42.1:4001/mod/v2/lock/update_lb?ttl=%s' % ttl) if r.status_code != 200: print 'unable to get a good lock, exiting: %s %s' % (r.status_code, r.text) sys.exit(1) return int(r.text) def release_lock(): r = requests.delete('http://172.17.42.1:4001/mod/v2/lock/update_lb/%d' % (lock_id)) if r.status_code != 200:
from libcloud.loadbalancer.types import Provider from libcloud.loadbalancer.providers import get_driver credentials = { "type": "service_account", "project_id": "my_project", "private_key": "-----BEGIN PRIVATE KEY-----\nmy_private_key_data\n" "-----END PRIVATE KEY-----\n", "client_email": "my_email", } LoadBalancer = get_driver(Provider.GCE) driver = LoadBalancer( "your_service_account_email", credentials, project="your_project_id" )
import libcloud.security libcloud.security.CA_CERTS_PATH.append('/app/cacert.pem') from libcloud.loadbalancer.base import Member, Algorithm from libcloud.loadbalancer.types import State, Provider from libcloud.loadbalancer.providers import get_driver import time import json import sys import os from urlparse import urlsplit import requests from config import config driver = get_driver(Provider.RACKSPACE_US)(config['rackspace_user'], config['rackspace_api_key']) ETCD_WATCH_VALUE = os.environ['ETCD_WATCH_VALUE'] ETCD_WATCH_KEY = os.environ['ETCD_WATCH_KEY'] ETCD_WATCH_MODIFIED_INDEX = os.environ['ETCD_WATCH_MODIFIED_INDEX'] def acquire_lock(ttl=5): r = requests.post('http://172.17.42.1:4001/mod/v2/lock/update_lb?ttl=%s' % ttl) if r.status_code != 200: print 'unable to get a good lock, exiting: %s %s' % (r.status_code, r.text) sys.exit(1) return int(r.text)
import time from pprint import pprint from libcloud.loadbalancer.base import Member, Algorithm from libcloud.loadbalancer.types import State, Provider from libcloud.loadbalancer.providers import get_driver driver = get_driver(Provider.RACKSPACE_US)('username', 'api key') name = 'test-lb' members = (Member(None, '192.168.86.1', 8080), Member(None, '192.168.86.2', 8080)) print 'Creating load balancer' new_balancer = driver.create_balancer(name=name, algorithm=Algorithm.ROUND_ROBIN, port=80, protocol='http', members=members) print 'Waiting for load balancer to become ready...' while True: balancer = driver.get_balancer(balancer_id=new_balancer.id) if balancer.state == State.RUNNING: break print 'Load balancer not ready yet, sleeping 20 seconds...' time.sleep(20) print 'Load balancer is ready'
from libcloud.loadbalancer.types import Provider from libcloud.loadbalancer.providers import get_driver LoadBalancer = get_driver(Provider.GCE) driver = LoadBalancer("service_account_email_or_client_id", "pem_file_or_client_secret", project="your_project_id")
import time from pprint import pprint from libcloud.loadbalancer.base import Member, Algorithm from libcloud.loadbalancer.types import State, Provider from libcloud.loadbalancer.providers import get_driver driver = get_driver(Provider.RACKSPACE_US)('username', 'api key') name = 'test-lb' members = (Member(None, '192.168.86.1', 8080), Member(None, '192.168.86.2', 8080)) print('Creating load balancer') new_balancer = driver.create_balancer(name=name, algorithm=Algorithm.ROUND_ROBIN, port=80, protocol='http', members=members) print('Waiting for load balancer to become ready...') while True: balancer = driver.get_balancer(balancer_id=new_balancer.id) if balancer.state == State.RUNNING: break print('Load balancer not ready yet, sleeping 20 seconds...') time.sleep(20) print('Load balancer is ready')
from libcloud.loadbalancer.base import Member, Algorithm from libcloud.loadbalancer.types import Provider from libcloud.loadbalancer.providers import get_driver ACCESS_ID = 'your access id' SECRET_KEY = 'your secret key' cls = get_driver(Provider.ELB) driver = cls(key=ACCESS_ID, secret=SECRET_KEY) print(driver.list_balancers()) # members associated with the load balancer members = (Member(None, '192.168.88.1', 8000), Member(None, '192.168.88.2', 8080)) new_balancer = driver.create_balancer(name='MyLB', algorithm=Algorithm.ROUND_ROBIN, port=80, protocol='http', members=members) print(new_balancer)
# # 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. from libcloud.compute.types import Provider as NodeProvider from libcloud.compute.providers import get_driver as get_node_driver from libcloud.loadbalancer.providers import get_driver from libcloud.loadbalancer.base import Algorithm, Member from libcloud.loadbalancer.types import Provider SLBDriver = get_driver(Provider.ALIYUN_SLB) ECSDriver = get_node_driver(NodeProvider.ALIYUN_ECS) region = "cn-hangzhou" your_access_key_id = "" your_access_key_secret = "" slb = SLBDriver(your_access_key_id, your_access_key_secret, region=region) ecs = ECSDriver(your_access_key_id, your_access_key_secret, region=region) protos = slb.list_protocols() print("Found %d protocols: %s" % (len(protos), protos)) balancers = slb.list_balancers() print("Found %d load balancers" % len(balancers)) print(balancers)
import time from pprint import pprint from libcloud.loadbalancer.base import Member, Algorithm from libcloud.loadbalancer.types import State, Provider from libcloud.loadbalancer.providers import get_driver driver = get_driver(Provider.RACKSPACE_US)("username", "api key") name = "test-lb" members = (Member(None, "192.168.86.1", 8080), Member(None, "192.168.86.2", 8080)) print("Creating load balancer") new_balancer = driver.create_balancer( name=name, algorithm=Algorithm.ROUND_ROBIN, port=80, protocol="http", members=members, ) print("Waiting for load balancer to become ready...") while True: balancer = driver.get_balancer(balancer_id=new_balancer.id) if balancer.state == State.RUNNING: break print("Load balancer not ready yet, sleeping 20 seconds...") time.sleep(20)
def openqrm_lc_get_connection(params): Driver = get_driver(Provider.ELB)(params['ACCESS_ID'], params['SECRET_KEY'], params['REGION']) return Driver