This is no longer supported, please consider using IONOS Cloud SDK Ruby instead.

Version: profitbricks-sdk-ruby v4.0.0

• Description
• Getting Started
  • Installation
  • Authenticating
• Reference
  • Data Centers
    • List Data Centers
    • Retrieve a Data Center
    • Create a Data Center
    • Update a Data Center
    • Delete a Data Center
  • Locations
    • List Locations
    • Get a Location
  • Servers
    • List Servers
    • Retrieve a Server
    • Create a Server
    • Update a Server
    • Delete a Server
    • List Attached Volumes
    • Attach a Volume
    • Retrieve an Attached Volume
    • Detach a Volume
    • List Attached CD-ROMs
    • Attach a CD-ROM
    • Retrieve an Attached CD-ROM
    • Detach a CD-ROM
    • Reboot a Server
    • Start a Server
    • Stop a Server
  • Images
    • List Images
    • Get an Image
    • Update an Image
    • Delete an Image
  • Volumes
    • List Volumes
    • Get a Volume
    • Create a Volume
    • Update a Volume
    • Delete a Volume
    • Create a Volume Snapshot
    • Restore a Volume Snapshot
  • Snapshots
    • List Snapshots
    • Get a Snapshot
    • Update a Snapshot
    • Delete a Snapshot
  • IP Blocks
    • List IP Blocks
    • Get an IP Block
    • Create an IP Block
    • Delete an IP Block
  • LANs
    • List LANs
    • Create a LAN
    • Get a LAN
    • Update a LAN
    • Delete a LAN
  • Network Interfaces (NICs)
    • List NICs
    • Get a NIC
    • Create a NIC
    • Update a NIC
    • Delete a NIC
  • Firewall Rules
    • List Firewall Rules
    • Get a Firewall Rule
    • Create a Firewall Rule
    • Update a Firewall Rule
    • Delete a Firewall Rule
  • Load Balancers
    • List Load Balancers
    • Get a Load Balancer
    • Create a Load Balancer
    • Update a Load Balancer
    • List Load Balanced NICs
    • Get a Load Balanced NIC
    • Associate NIC to a Load Balancer
    • Remove a NIC Association
  • User Management
    • List Groups
    • Get a Group
    • Create a Group
    • Update a Group
    • Delete a Group
    • List Shares
    • Get a Share
    • Add a Share
    • Update a Share
    • Delete a Share
    • List Users
    • Get a User
    • Create a User
    • Update a User
    • Delete a User
    • List Users in a Group
    • Add User to Group
    • Remove User from a Group
    • List Resources
    • Get a Resource
  • Contract Resources
    • List Contract Resources
  • Requests
    • List Requests
    • Get a Request
    • Get a Request Status
• Support
• Testing
• Contributing

This Ruby library is a wrapper for the ProfitBricks REST API. All API operations are performed over SSL and authenticated using your ProfitBricks portal credentials. The API can be accessed within an instance running in ProfitBricks or directly over the Internet from any application that can send an HTTPS request and receive an HTTPS response.

This guide will show you how to programmatically perform common management tasks using the ProfitBricks SDK for Ruby.

• ProfitBricks account

Before you begin you will need to have signed-up for a ProfitBricks account. The credentials you setup during sign-up will be used to authenticate against the API.

The official ProfitBricks Ruby library is available from the ProfitBricks GitHub account found here. You can download the latest stable version by cloning the repository and then adding the project to your solution.

Once the SDK is downloaded:

Add this line to your application's Gemfile:

gem 'profitbricks-sdk-ruby'

And then execute:

$ bundle

Or install it yourself as:

$ gem install profitbricks-sdk-ruby

Connecting to ProfitBricks is handled by first setting up your authentication credentials.

To setup your credentials you will have to provide configure and provide your username and password

ProfitBricks.configure do |config|
  config.url = 'https://api.profitbricks.com/cloudapi/v4/'
  config.username = ENV['PROFITBRICKS_USERNAME']
  config.password = ENV['PROFITBRICKS_PASSWORD']
  config.debug = false
  config.timeout = 300
  config.interval = 5
  config.depth=5
end

You can choose to read them from the environment variables like in the example above, or just provide the strting value for username and password.

This section provides details on all the available operations and the parameters they accept. Brief code snippets demonstrating usage are also included.

Virtual data centers (VDCs) are the foundation of the ProfitBricks platform. VDCs act as logical containers for all other objects you will be creating, e.g., servers. You can provision as many VDCs as you want. VDCs have their own private network and are logically segmented from each other to create isolation.

This operation will list all currently provisioned VDCs that your account credentials provide access to.

The optional depth parameter can be set from the ProfitBricks.configure and it defines the level, one being the least and five being the most, of information returned with the response.

datacenters = ProfitBricks::Datacenter.list

Use this to retrieve details about a specific VDC.

The following table describes the request arguments:

datacenter = ProfitBricks::Datacenter.get(datacenter_id)

Use this operation to create a new VDC. You can create a "simple" VDC by supplying just the required name and location parameters. This operation also has the capability of provisioning a "complex" VDC by supplying additional parameters for servers, volumes, LANs, and/or load balancers.

The following table describes the request arguments:

The following table outlines the locations currently supported:

NOTES:

• The value for name cannot contain the following characters: (@, /, , |, ‘’, ‘).
• You cannot change the virtual data center location once it has been provisioned.

datacenter = ProfitBricks::Datacenter.create(
      name: 'Ruby SDK Composite Datacenter',
      description: 'SDK  Composite test environment',
      location: 'de/fkb',
      servers: [
        {
          name: 'New Composite Server',
          ram: 1024,
          cores: 1,
          volumes: [
            {
              name: 'composite-boot',
              size: 5,
              type: 'HDD',
              licenceType: 'UNKNOWN'
            }
          ]
        }
      ]
    )

After retrieving a data center, either by getting it by id, or as a create response object, you can change its properties by calling the the update method. Some parameters may not be changed using either of the update methods.

The following table describes the available request arguments:

datacenter.update(name: 'datacenter1', description: 'Ruby SDK test environment')

This will remove all objects within the virtual data center AND remove the virtual data center object itself.

NOTE: This is a highly destructive operation which should be used with extreme caution!

The following table describes the available request arguments:

datacenter.delete;

Locations are the physical ProfitBricks data centers where you can provision your VDCs.

This operation will return the list of currently available locations.

The optional depth parameter can be set from the ProfitBricks.configure and it defines the level, one being the least and five being the most, of information returned with the response.

locations = ProfitBricks::Location.list

Retrieves the attributes of a specific location.

The following table describes the request arguments:

location = ProfitBricks::Location.get(location_id)

You can retrieve a list of all the servers provisioned inside a specific VDC.

The following table describes the request arguments:

servers = ProfitBricks::Server.list(datacenter_id)

Returns information about a specific server such as its configuration, provisioning status, etc.

The following table describes the request arguments:

server = ProfitBricks::Server.get(datacenter_id, server_id)

Creates a server within an existing VDC. You can configure additional properties such as specifying a boot volume and connecting the server to a LAN.

The following table describes the request arguments:

The following table outlines the server availability zones currently supported:

server = ProfitBricks::Server.create(
      datacenter_id,
      name: 'New Composite Server',
      ram: 1024,
      cores: 1,
      volumes: [
        {
          name: 'composite-boot',
          size: 5,
          type: 'HDD',
          licenceType: 'UNKNOWN'
        }
      ],
      nics: [
        {
          name: 'nic1',
          dhcp: 'true',
          lan: 1,
          firewallrules: [
            {
              name: 'SSH',
              protocol: 'TCP',
              portRangeStart: 22,
              portRangeEnd: 22,
            }
          ]
        }
      ])

Perform updates to the attributes of a server.

The following table describes the request arguments:

After retrieving a server, either by getting it by id, or as a create response object, you can change its properties and call the update method:

server = server.update(
 name: 'New Server - Updated',
 cores: 2
)

This will remove a server from a data center. NOTE: This will not automatically remove the storage volume(s) attached to a server. A separate operation is required to delete a storage volume.

The following table describes the request arguments:

After retrieving a server, either by getting it by id, or as a create response object, you can call the delete method directly:

server.delete

Retrieves a list of volumes attached to the server.

The following table describes the request arguments:

After retrieving a server, either by getting it by id, or as a create response object, you can call the list_volumes method directly on the server instance:

server = ProfitBricks::Server.get(datacenter_id, server_id)
volumes = server.list_volumes

This will attach a pre-existing storage volume to the server.

The following table describes the request arguments:

After retrieving a server, either by getting it by id, or as a create response object, you can call the attach_volume method directly.

server = ProfitBricks::Server.get(datacenter_id, server_id)
volume = server.attach_volume(volume_id)

This will retrieve the properties of an attached volume.

The following table describes the request arguments:

After retrieving a server, either by getting it by id, or as a create response object, you can call the get_volume method directly.

server = ProfitBricks::Server.get(datacenter_id, server_id)
volume = server.get_volume(volume_id)

This will detach the volume from the server. Depending on the volume hot_unplug settings, this may result in the server being rebooted.

This will NOT delete the volume from your virtual data center. You will need to make a separate request to delete a volume.

The following table describes the request arguments:

After retrieving a server, either by getting it by id, or as a create response object, you can call the detach_volume method directly.

server = ProfitBricks::Server.get(datacenter_id, server_id)
volume = server.detach_volume(volume_id)

Retrieves a list of CD-ROMs attached to a server.

The following table describes the request arguments:

After retrieving a server, either by getting it by id, or as a create response object, you can call the list_cdroms method directly.

server = ProfitBricks::Server.get(datacenter_id, server_id)
cdroms = server.list_cdroms

You can attach a CD-ROM to an existing server.

The following table describes the request arguments:

After retrieving a server, either by getting it by id, or as a create response object, you can call the attach_cdrom method directly.

server = ProfitBricks::Server.get(datacenter_id, server_id)
image = server.attach_cdrom(cdrom_image_id)

You can retrieve a specific CD-ROM attached to the server.

The following table describes the request arguments:

After retrieving a server, either by getting it by id, or as a create response object, you can call the get_cdrom method directly.

server = ProfitBricks::Server.get(datacenter_id, server_id)
cdrom = server.get_cdrom(image.id)

This will detach a CD-ROM from the server.

The following table describes the request arguments:

After retrieving a server, either by getting it by id, or as a create response object, you can call the detach_cdrom method directly.

server = ProfitBricks::Server.get(datacenter_id, server_id)
server.detach_cdrom(cdrom_image_id)

This will force a hard reboot of the server. Do not use this method if you want to gracefully reboot the machine. This is the equivalent of powering off the machine and turning it back on.

The following table describes the request arguments:

After retrieving a server, either by getting it by id, or as a create response object, you can call the reboot method directly.

server = ProfitBricks::Server.get(datacenter_id, server_id)
server.reboot

This will start a server. If the server's public IP was deallocated then a new IP will be assigned.

The following table describes the request arguments:

After retrieving a server, either by getting it by id, or as a create response object, you can call the start method directly.

server = ProfitBricks::Server.get(datacenter_id, server_id)
server.start

This will stop a server. The machine will be forcefully powered off, billing will cease, and the public IP, if one is allocated, will be deallocated.

The following table describes the request arguments:

After retrieving a server, either by getting it by id, or as a create response object, you can call the stop method directly.

server = ProfitBricks::Server.get(datacenter_id, server_id)
server.stop

Retrieve a list of images.

The optional depth parameter can be set from the ProfitBricks.configure and it defines the level, one being the least and five being the most, of information returned with the response.

images = ProfitBricks::Image.list

Retrieves the attributes of a specific image.

The following table describes the request arguments:

 ProfitBricks::Image.get(image_id)

Retrieve a list of volumes within the virtual data center. If you want to retrieve a list of volumes attached to a server please see the List Attached Volumes entry in the Server section for details.

The following table describes the request arguments:

volumes = ProfitBricks::Volume.list(datacenter_id)

Retrieves the attributes of a given volume.

The following table describes the request arguments:

volumes = ProfitBricks::Volume.get(datacenter_id,volume_id)

Creates a volume within the virtual data center. This will NOT attach the volume to a server. Please see the Attach a Volume entry in the Server section for details on how to attach storage volumes.

The following table describes the request arguments:

The following table outlines the various licence types you can define:

The following table outlines the storage availability zones currently supported:

• You will need to provide either the image or the licenceType parameters. licenceType is required, but if image is supplied, it is already set and cannot be changed. Similarly either the imagePassword or sshKeys parameters need to be supplied when creating a volume. We recommend setting a valid value for imagePassword even when using sshKeys so that it is possible to authenticate using the remote console feature of the DCD.

volume = ProfitBricks::Volume.create(
  datacenter_id, name: 'my boot volume for server 1',
  size: 5,
  type: 'HDD',
  licenceType: 'UNKNOWN',
  availabilityZone: 'AUTO')

You can update -- in full or partially -- various attributes on the volume; however, some restrictions are in place:

You can increase the size of an existing storage volume. You cannot reduce the size of an existing storage volume. The volume size will be increased without requiring a reboot if the relevant hot plug settings have been set to true. The additional capacity is not added automatically added to any partition, therefore you will need to handle that inside the OS afterwards. Once you have increased the volume size you cannot decrease the volume size.

Since an existing volume is being modified, none of the request parameters are specifically required as long as the changes being made satisfy the requirements for creating a volume.

The following table describes the request arguments:

After retrieving a volume, either by getting it by id, or as a create response object, you can change its properties and call the update method:

volume = volume.update(
 name: 'Resized storage to 15 GB',
 size: 15
)

Deletes the specified volume. This will result in the volume being removed from your data center. Use this with caution.

The following table describes the request arguments:

After retrieving a volume, either by getting it by id, or as a create response object, you can call the delete method directly.

volumes = ProfitBricks::Volume.get(datacenter_id,volume_id)
volume.delete

Creates a snapshot of a volume within the virtual data center. You can use a snapshot to create a new storage volume or to restore a storage volume.

The following table describes the request arguments:

After retrieving a volume, either by getting it by id, or as a create response object, you can call the create_snapshot method directly.

volume = ProfitBricks::Volume.get(datacenter_id,volume_id)
snapshot = volume.create_snapshot(
      name: 'Snapshot of storage X on 12.12.12 12:12:12 - updated',
      description: 'description of a snapshot - updated')

This will restore a snapshot onto a volume. A snapshot is created as just another image that can be used to create new volumes or to restore an existing volume.

The following table describes the request arguments:

After retrieving a volume, either by getting it by id, or as a create response object, you can call the restore_snapshot method directly.

volume = ProfitBricks::Volume.get(datacenter_id,volume_id)
volume.restore_snapshot(snapshot_id)

You can retrieve a list of all available snapshots.

The optional depth parameter can be set from the ProfitBricks.configure and it defines the level, one being the least and five being the most, of information returned with the response.

snapshots = ProfitBricks::Snapshot.list

Retrieves the attributes of a specific snapshot.

The following table describes the request arguments:

snapshot = ProfitBricks::Snapshot.get(snapshot_id)

Perform updates to attributes of a snapshot.

The following table describes the request arguments:

After retrieving a snapshot, either by getting it by id, or as a create response object, you can change its properties and call the update method:

snapshot = ProfitBricks::Snapshot.get(snapshot_id)
snapshot = snapshot.update(name: 'New name')

Deletes the specified snapshot.

The following table describes the request arguments:

After retrieving a snapshot, either by getting it by id, or as a create response object, you can call the delete method directly.

snapshot = ProfitBricks::Snapshot.get(snapshot_id)
snapshot.delete

The IP block operations assist with managing reserved /static public IP addresses.

Retrieve a list of available IP blocks.

ipblocks = ProfitBricks::IPBlock.list

Retrieves the attributes of a specific IP block.

The following table describes the request arguments:

ipblock = ProfitBricks::IPBlock.get(ipblock_id)

Creates an IP block. IP blocks are attached to a location, so you must specify a valid location along with a size parameter indicating the number of IP addresses you want to reserve in the IP block. Servers or other resources using an IP address from an IP block must be in the same location.

The following table describes the request arguments:

The following table outlines the locations currently supported:

To create an IP block, establish the parameters and then call reserve.

ipblock = ProfitBricks::IPBlock.reserve
 (
    location: "de/fra",
    size: 1
  )

Deletes the specified IP Block.

The following table describes the request arguments:

After retrieving an IP block, either by getting it by id, or as a create response object, you can call the release method directly.

ipblock = ProfitBricks::IPBlock.get(ipblock_id)
ipblock.release

Retrieve a list of LANs within the virtual data center.

The following table describes the request arguments:

lans = ProfitBricks::LAN.list(datacenter_id)

Creates a LAN within a virtual data center.

The following table describes the request arguments:

lan = ProfitBricks::LAN.create(datacenter_id,  name: 'public Lan 4',
  public: 'true')

Retrieves the attributes of a given LAN.

The following table describes the request arguments:

lan = ProfitBricks::LAN.get(datacenter_id, lan_id)

Perform updates to attributes of a LAN.

The following table describes the request arguments:

After retrieving a LAN, either by getting it by id, or as a create response object, you can change its properties and call the update method:

lan = lan.update(public: false)

Deletes the specified LAN.

The following table describes the request arguments:

After retrieving a LAN, either by getting it by id, or as a create response object, you can call the delete method directly.

lan = ProfitBricks::LAN.get(datacenter_id, lan_id)
lan.delete

Retrieve a list of LANs within the virtual data center.

The following table describes the request arguments:

nics = ProfitBricks::NIC.list(datacenter_id, server_id)

Retrieves the attributes of a given NIC.

The following table describes the request arguments:

nic = ProfitBricks::NIC.get(datacenter_id, server_id, nic_id)

Adds a NIC to the target server.

The following table describes the request arguments:

nic = ProfitBricks::NIC.create
  (
    datacenter_id, server_id,  name: 'nic1',
    dhcp: true,
    lan: 1,
    firewallActive: true,
    nat: false)

You can update -- in full or partially -- various attributes on the NIC; however, some restrictions are in place:

The primary address of a NIC connected to a load balancer can only be changed by changing the IP of the load balancer. You can also add additional reserved, public IPs to the NIC.

The user can specify and assign private IPs manually. Valid IP addresses for private networks are 10.0.0.0/8, 172.16.0.0/12 or 192.168.0.0/16.

The following table describes the request arguments:

After retrieving a NIC, either by getting it by id, or as a create response object, you can call the update method directly.

nic = ProfitBricks::NIC.get(datacenter_id, server_id, nic_id)
nic = nic.update(ips: ['10.1.1.1', '10.1.1.2'])

Deletes the specified NIC.

The following table describes the request arguments:

After retrieving a NIC, either by getting it by id, or as a create response object, you can call the Delete method directly.

nic = ProfitBricks::NIC.get(datacenter_id, server_id, nic_id)
nic.delete

Retrieves a list of firewall rules associated with a particular NIC.

The following table describes the request arguments:

fwrules = ProfitBricks::Firewall.list(datacenter_id, server_id, nic_id)

Retrieves the attributes of a given firewall rule.

The following table describes the request arguments:

fwrule = ProfitBricks::Firewall.get(datacenter_id, server_id, nic_id, firewall_rule_id)

This will add a firewall rule to the NIC.

The following table describes the request arguments:

fwrule = ProfitBricks::Firewall.create(
  datacenter_id, server_id, nic_id, name: 'SSH',
  protocol: 'TCP',
  sourceMac: '01:23:45:67:89:00',
  sourceIp: nil,
  targetIp: nil,
  portRangeStart: 22,
  portRangeEnd: 22,
  icmpType: nil,
  icmpCode: nil)

Perform updates to attributes of a firewall rule.

The following table describes the request arguments:

After retrieving a firewall rule, either by getting it by id, or as a create response object, you can change its properties and call the update method:

fwrule = ProfitBricks::Firewall.get(datacenter_id, server_id, nic_id, firewall_rule_id)
fwrule = fwrule.update(
  sourceMac: '01:98:22:22:44:22',
  targetIp: '123.100.101.102'
  )

Removes the specific firewall rule.

After retrieving a firewall rule, either by getting it by id, or as a create response object, you can call the delete method directly.

fwrule = ProfitBricks::Firewall.get(datacenter_id, server_id, nic_id, firewall_rule_id)
fwrule.delete

Retrieve a list of load balancers within the data center.

The following table describes the request arguments:

loadbalancers = ProfitBricks::Loadbalancer.list(datacenter_id)

Retrieves the attributes of a given load balancer.

The following table describes the request arguments:

loadbalancer = ProfitBricks::Loadbalancer.get(datacenter_id, loadbalancer_id)

Creates a load balancer within the virtual data center. Load balancers can be used for public or private IP traffic.

The following table describes the request arguments:

loadbalancer = ProfitBricks::Loadbalancer.create(
  datacenter_id, name: 'My LB',
  # ip: '10.2.2.3',
  dhcp: 'true')

Perform updates to attributes of a load balancer.

The following table describes the request arguments:

After retrieving a load balancer, either by getting it by id, or as a create response object, you can change it's properties and call the update method:

loadbalancer = ProfitBricks::Loadbalancer.get(datacenter_id, loadbalancer_id)
loadbalancer = loadbalancer.update(
  ip: '10.1.1.2'
  )

Deletes the specified load balancer.

The following table describes the request arguments:

After retrieving a load balancer, either by getting it by id, or as a create response object, you can call the delete method directly.

loadbalancer = ProfitBricks::Loadbalancer.get(datacenter_id, loadbalancer_id)
loadbalancer.delete

This will retrieve a list of NICs associated with the load balancer.

The following table describes the request arguments:

After retrieving a load balancer, either by getting it by id, or as a create response object, you can call the list_balanced_nics method directly.

loadbalancer = ProfitBricks::Loadbalancer.get(datacenter_id, loadbalancer_id)
balanced_nics = loadbalancer.list_balanced_nics

Retrieves the attributes of a given load balanced NIC.

The following table describes the request arguments:

After retrieving a load balancer, either by getting it by id, or as a create response object, you can call the get_balanced_nic method directly.

loadbalancer = ProfitBricks::Loadbalancer.get(datacenter_id, loadbalancer_id)
nic = ProfitBricks::NIC.get(datacenter_id, server_id, nic_id)
balanced_nic = loadbalancer.get_balanced_nic(nic_id)

This will associate a NIC to a load balancer, enabling the NIC to participate in load-balancing.

The following table describes the request arguments:

After retrieving a load balancer, either by getting it by id, or as a create response object, you can call the associate_balanced_nic method directly.

loadbalancer = ProfitBricks::Loadbalancer.get(datacenter_id, loadbalancer_id)
nic = ProfitBricks::NIC.get(datacenter_id, server_id, nic_id)
balanced_nic = loadbalancer.associate_balanced_nic(nic.id)

Removes the association of a NIC with a load balancer.

The following table describes the request arguments:

After retrieving a load balancer, either by getting it by id, or as a create response object, you can call the remove_balanced_nic method directly.

loadbalancer.remove_balanced_nic(nic.id)

Retrieves a list of all groups.

The following table describes the options arguments:

groups = ProfitBricks::Group.list()

Retrieves the attributes of a given group.

The following table describes the request arguments:

The following table describes the options arguments:

response = ProfitBricks::Group.get(group_id)

Creates a new group and set group privileges.

The following table describes the request arguments:

group = { name: 'my group', createDataCenter: true, createSnapshot: true, reserveIp: true, accessActivityLog: true }

response = ProfitBricks::Group.create(group)

Updates a group's name or privileges.

The following table describes the request arguments:

group = ProfitBricks::Group.get(group_id)
group = group.update(
  name: 'my group RENAME',
  createDataCenter: false
)

Deletes the specified group.

The following table describes the request arguments:

group = ProfitBricks::Group.get(group_id)
response = group.delete

Retrieves a list of all shares though a group.

The following table describes the options arguments:

response = ProfitBricks::Share.list(group_id)

Retrieves a specific resource share available to a group.

The following table describes the request arguments:

The following table describes the options arguments:

response = ProfitBricks::Share.get(
    group_id,
    resource_id)

Shares a resource through a group.

The following table describes the request arguments:

share = {
          editPrivilege: true,
          sharePrivilege: true
        }
response = ProfitBricks::Share.create(group_id, resource_id, share)

Updates the permissions of a group for a resource share.

The following table describes the request arguments:

The following table describes the options arguments:

share = ProfitBricks::Share.update(group_id, resource_id, {
  editPrivilege: false
})

Removes a resource share from a group.

ProfitBricks::Share.delete(group_id, resource_id)

Retrieves a list of all users.

The following table describes the options arguments:

response =  ProfitBricks::User.list()

Retrieves a single user.

The following table describes the options arguments:

response = ProfitBricks::User.get(user_id)

Creates a new user.

The following table describes the request arguments:

user = {
        firstname: 'John',
        lastname: 'Doe',
        email: 'no-reply@example.com',
        password: 'secretpassword123',
        administrator: 'administrator',
        forceSecAuth: false
      }

response = ProfitBricks::User.create(user)

Updates an existing user.

The following table describes the request arguments:

user = ProfitBricks::User.get(user_id)
  response = user.update(
  administrator: false,
  firstname: 'John',
  lastname: 'Doe',
  email: 'no-reply@example.com',
  forceSecAuth: false
)

Removes a user.

user = ProfitBricks::User.get(user_id)
response = user.delete

Retrieves a list of all users that are members of a particular group.

The following table describes the options arguments:

response = ProfitBricks::User.list(group_id: 'UUID')

Adds an existing user to a group.

The following table describes the request arguments:

response = user = ProfitBricks::User.add_to_group(group_id,user_id)

Removes a user from a group.

response = ProfitBricks::User.remove_from_group(group_id,user_id)

Retrieves a list of all resources. Alternatively, Retrieves all resources of a particular type.

The following table describes the request arguments:

The following table describes the options arguments:

response = ProfitBricks::Resource.list

response = ProfitBricks::Resource.list_by_type('datacenter')

Retrieves a single resource of a particular type.

The following table describes the request arguments:

The following table describes the options arguments:

response = ProfitBricks::Resource.get('datacenter', datacenter_id)

Retrieves information about the resource limits for a particular contract and the current resource usage.

The following table describes the options arguments:

response = ProfitBricks::Contract.get

Each call to the ProfitBricks Cloud API is assigned a request ID. These operations can be used to get information about the requests that have been submitted and their current status.

Retrieve a list of requests.

requests = ProfitBricks::Request.list

Retrieves the attributes of a specific request.

The following table describes the request arguments:

request = ProfitBricks::Request.get(request_id)

Retrieves the status of a request.

The following table describes the request arguments:

request = ProfitBricks::Request.get(request_id)
status = request.status

• A guide and reference documentation can be found in the repo docs/ directory.
• ProfitBricks SDK for Ruby guide.
• ProfitBricks REST API documentation.
• Ask a question or discuss at ProfitBricks DevOps Central.
• Report an issue here.

Please note that the unit tests will create and destroy live resources under the account specified and you will be responsible for any charges incurred. Proceed with caution.

Add the ProfitBricks API credentials to the spec/spec_helper.rb file and run the following command.

$ rspec spec

1. Fork it ( https://github.com/[my-github-username]/profitbricks-sdk-ruby/fork )
2. Create your feature branch (git checkout -b my-new-feature)
3. Commit your changes (git commit -am 'Add some feature')
4. Push to the branch (git push origin my-new-feature)
5. Create a new Pull Request