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
