Metadata-Version: 2.1
Name: libcloud_driver_kamatera
Version: 0.0.1
Summary: Apache Libcloud driver for managing Kamatera compute resources
Home-page: https://github.com/Kamatera/libcloud-driver-kamatera
Author: Kamatera
License: MIT
Description: # Apache Libcloud driver for Kamatera
        
        ## Installation
        
        * Install [Libcloud](https://libcloud.apache.org/) (Version 2.8.2 or higher)
        * Install the driver, using the same Python interpreter that Libcloud was installed in:
          * `pip install libcloud-driver-kamatera`
        
        ## Usage
        
        ### Enabling API access
        
        To allow API access to your Kamatera account, you first need to add an API key
        by visiting [Kamatera Console](https://console.kamatera.com) and adding a new key under API Keys.
        Use the created key Client ID and Secret as the arguments to the driver constructor.
        
        ### Instantiating a driver
        
        ```
        from libcloud_driver_kamatera import get_node_driver
        
        cls = get_node_driver()
        driver = cls('KAMATERA API CLIENT ID', 'KAMATERA API SECRET')
        ```
        
        ### Getting server options
        
        Select a location
        
        ```
        locations = {location.id: location for location in driver.list_locations()}
        for location in locations.values():
            print(location)
        
        # <NodeLocation: id=AS, name=Hong Kong, country=China
        # <NodeLocation: id=CA-TR, name=Toronto, country=Canada
        # <NodeLocation: id=EU, name=Amsterdam, country=The Netherlands
        # <NodeLocation: id=EU-FR, name=Frankfurt, country=Germany
        # <NodeLocation: id=EU-LO, name=London, country=United Kingdom
        # <NodeLocation: id=IL, name=Rosh Haayin, country=Israel
        # <NodeLocation: id=IL-JR, name=Jerusalem, country=Israel
        # <NodeLocation: id=IL-PT, name=Petach Tikva, country=Israel
        # <NodeLocation: id=IL-RH, name=Rosh Haayin 2, country=Israel
        # <NodeLocation: id=IL-TA, name=Tel Aviv, country=Israel
        # <NodeLocation: id=US-NY2, name=New York, country=United States
        # <NodeLocation: id=US-SC, name=Santa Clara, country=United States
        # <NodeLocation: id=US-TX, name=Texas, country=United States
        
        location = locations['US-NY2']
        ```
        
        Create a node size object
        
        ```
        # get the capabilities for this location
        
        capabilities = driver.ex_list_capabilities(location)
        
        # choose a cpu type
        
        cpuTypes = {cpuType['id']: cpuType for cpuType in capabilities['cpuTypes']}
        for cpuType in cpuTypes.values():
            print('%s: %s' % (cpuType['name'], cpuType['description']))
        
        # Type B - General Purpose: Server CPUs are assigned to a dedicated physical
        #          CPU Thread with reserved resources guaranteed.
        # Type D - Dedicated: Server CPU are assigned to a dedicated physical CPU Core
        #          (2 threads) with reserved resources guaranteed.
        # Type T - Burstable: Server CPUs are assigned to a dedicated physical CPU
        #          thread with reserved resources guaranteed.
        # Type A - Availability: Server CPUs are assigned to a non-dedicated physical
        #          CPU thread with no resources guaranteed.
        
        cpuType = cpuTypes['B']
        
        # choose number of cpu cores
        
        print(cpuType['cpuCores'])
        
        # [1, 2, 4, 6, 8, 12, 16, 20, 24, 28, 32, 36, 40, 48, 56, 64, 72]
        
        cpuCores = 2
        
        # choose amount of RAM
        
        print(cpuType['ramMB'])
        
        # [256, 512, 1024, 2048, 3072, 4096, 6144, 8192, 10240, 12288, 16384, 24576,
        #  32768, 49152, 65536, 98304, 131072, 200704, 262144, 327680, 393216]
        
        ramMB = 2048
        
        # choose disk sizes
        
        print(capabilities['diskSizeGB'])
        
        # [5, 10, 15, 20, 30, 40, 50, 60, 80, 100, 150, 200, 250, 300, 350, 400, 450,
        #  500, 600, 700, 800, 900, 1000, 1500, 2000, 3000, 4000]
        
        # primary disk size
        
        diskSizeGB = 20
        
        # additional disks (up to 3 additional disks)
        
        extraDiskSizesGB = [100, 200]
        
        # choose a billing cycle
        
        billingCycle = driver.EX_BILLINGCYCLE_MONTHLY
        # billingCycle = driver.EX_BILLINGCYCLE_HOURLY
        
        # in case of monthly billing cycle, choose traffic package
        
        print(capabilities['monthlyTrafficPackage'])
        
        # {'b50': '50Mbit/sec unmetered on 10Gbit/sec port',
        #  't5000': '5000GB/month on 10Gbit/sec port'}
        
        monthlyTrafficPackage = 't5000'
        
        # create node size object
        
        size = driver.ex_get_size(ramMB, diskSizeGB, cpuType['id'], cpuCores,
                                  extraDiskSizesGB=extraDiskSizesGB,
                                  monthlyTrafficPackage=monthlyTrafficPackage)
        ```
        
        Choose an OS image
        
        ```
        images = {image.id: image for image in driver.list_images(location)}
        
        for image in images.values():
            print('%s: %s' % (image.id, image.name))
        
        # list is shortened, actual list will vary and provide more OS image options
        
        # US-NY2:6000C2987c9641fd2619a149ba2ca01a: CentOS 8.0 64-bit - Minimal
        # US-NY2:6000C29b85c6367d215d403f44c28f48: CentOS 8.0 64-bit - Basic Server
        # US-NY2:6000C29bb8fde673f515caf9bed695a1: Debian version 8.9 (jessie) 64-bit
        # US-NY2:6000C29e4131d66b806c25c48ab0b810: FreeBSD 12.1 64-bit
        # US-NY2:6000C2983bdd8b531ecfc6d892a35aa4: FreeBSD 11.1 32-bit
        # US-NY2:6000C29a5a7220dcf84716e7bba74215: Ubuntu Server version 18.04 LTS
        # US-NY2:6000C298bbb2d3b6e9721f4f4f3c5bf0: Ubuntu Server version 16.04 LTS
        
        image = images['US-NY2:6000C29a5a7220dcf84716e7bba74215']
        ```
        
        Set network configurations (up to 4 interfaces can be added)
        
        ```
        networks = []
        ```
        
        Add a wan to get a public IP
        
        ```
        networks.append({'name': 'wan', 'ip': 'auto'})
        ```
        
        add a vlan interface to get a private IP
        (vlan network name and ip should be configured in the Kamatera console)
        
        ```
        networks.append({'name': '12345-my-vlan', 'ip': 'auto'})
        ```
        
        ### Create a server
        
        ```
        node = driver.create_node(
            name='test_libcloud_server',
            size=size,
            image=image,
            location=location,
            ex_networks=networks,
            ex_dailybackup=False,  # create daily backups for the node?
            ex_managed=False,  # provide managed support for the node?
            ex_billingcycle=billingCycle
        )
        ```
        
        Get the SSH connection details
        
        ```
        print('root@%s  /  %s' % (node.public_ips[0],
                                  node.extra['generated_password']))
        ```
        
        ### Server operations
        
        List all nodes (quick operation, provides only basic details for each node)
        
        ```
        nodes = driver.list_nodes()
        ```
        
        Get more details for a specific node
        
        ```
        node = driver.list_nodes(ex_id=nodes[0].id)[0]
        print(node)
        ```
        
        List nodes with full details based on regex of node name
        
        ```
        nodes = driver.list_nodes(ex_name_regex='test_libcloud.*')
        print(nodes[0])
        
        # <Node: uuid=9566552b254b42063e87ba644a982d330602b06c,
        #        name=test_libcloud_server, state=RUNNING,
        #        public_ips=['138.128.241.118'], private_ips=[], provider=Kamatera
        
        print(nodes[0].extra)
        
        # {'billingcycle': 'monthly', 'priceOn': '25', 'priceOff': '25',
        #  'location': <NodeLocation: id=US-NY2>, 'dailybackup': False,
        #  'managed': False}
        ```
        
        list all nodes with full details (slower operation)
        
        ```
        nodes = driver.list_nodes(ex_full_details=True)
        node = nodes[0]
        ```
        
        run operations
        
        ```
        driver.start_node(node)
        driver.stop_node(node)
        driver.reboot_node(node)
        driver.destroy_node(node)
        ```
        
Platform: UNKNOWN
Description-Content-Type: text/markdown
