• Packet Provider for Fog
• Requirements
• Installation
• Build
• Authentication
• Operations
  • Servers
  • Volumes
  • Snapshots
  • IP Addresses
  • Projects
  • Plans
  • Facilities
  • Users
  • Emails
  • VPN
  • Spot Market Prices
  • SSH Keys
  • Batches
  • BGP Sessions
  • Two Factor Authentication
  • Sessions
  • Notifications
  • Invitations
  • UserVerificationTokens
  • Licenses
  • Memberships
  • Capacity
  • Payment Methods
  • Project Transfer Requests
  • Hardware Reservations
• Unit Tests
• Support

Packet provides an API drive-driven bare metal platform that brings the price and performance benefits of bare metal servers and network to the cloud.

Fog is a Ruby library that provides a consistent framework for interacting with the various cloud providers and their services. The Packet provider for Fog adds powerful bare metal to the growing list of cloud services.

1. Ruby version 2.2 and above.

Add this line to your application's Gemfile:

gem 'fog-packet'

And then execute:

$ bundle

Or install it yourself as:

$ gem install fog-packet

In some cases it might be necessary to manually build the package from source:

1. Clone the repository:

$ git clone https://github.com/fog/fog-packet

2. Change into the repository root and build the gem package:

$ cd fog-packet
$ gem build fog-packet.gemspec

3. Install the Ruby gem:

$ gem install fog-packet-1.1.0.gem

Provide your credentials when creating a compute object:

require 'fog-packet'

compute = Fog::Compute::Packet.new(packet_token: 'PACKET_TOKEN')

Alternatively, the Packet token can be supplied as an environment variable:

$ export PACKET_TOKEN="PACKET_TOKEN"

require 'fog-packet'

compute = Fog::Compute::Packet.new()

Creates a new server and provisions it in our datacenter.

device = compute.devices.create(:project_id => project_id, :facility => "ewr1", :plan => "baremetal_0", :hostname => "test01", :operating_system => "coreos_stable", :user_ssh_keys => ["ssh_key_id"])

Available parameters

| NAME| TYPE | DESCRIPTION | REQUIRED |
|---|---|---|---|
| project_id | string | 	Project UUID  under which server will be created| Yes |
| hostname | string | The hostname of the server. | Yes |
| plan | string | Plan name| Yes |
| facility | string | Facility code | Yes |
| operating_system | string || No |
| description | string | | No* |
| billing_cycle | string | | No |
| always_pxe | string | | No |
| ipxe_script_url | string | | No |
| userdata | string | | No |
| locked | string | | No |
| hardware_reservation_id | string | | No |
| spot_instance | string | | No |
| spot_price_max | string | | No |
| termination_time | string | | No |
| tags | string | | No |
| project_ssh_keys | collection of strings | | No |
| user_ssh_keys | collection of strings | | No |
| features | string | | No |

## Retrieve a server

Gets details about a specified server

```ruby
response = compute.servers.get(server_id)

Updates a server

server.hostname= 'test02'

response = server.update

Available parameters

Reboots the specified server

response = server.reboot

Powers off the specified server

response = server.stop

Powers on the specified server

response = server.start

Deletes the specified servers

response = server.destroy

Returns a list of events pertaining to a specific server.

events = compute.events.all(server_id)

Retrieve an instance bandwidth for a given period of time.

bandwidth = compute.bandwidth.get(server_id, "2018-03-10", "2018-04-10")

Creates a new volume

volume = compute.volumes.create(:project_id => project_id, :facility => "ewr1", :plan => "storage_1", :size => 20, :description => "test description", :billing_cycle => "hourly")

Available parameters

Gets a specified volume

response = compute.volumes.get(volume_id)

List all volumes in the specified project

response = compute.volumes.all(project_id)

Optional parameters

Attaches a volume to the specified server

response = volume.attach(server_id)

Detaches a volume from the specified server

response = volume.detach

Deletes a specified volume

response = volume.destroy

Creates a snapshot of the specified volume

response = compute.snapshots.create(:storage_id => volume_id)

List all snapshots of the specified volume

response = compute.snapshots.all(volume_id)

Optional parameters

Deletes the specified snapshot

response = snapshot.destroy

Reserve an IP address

response = compute.ips.create(:project_id => project_id, :facility => "ewr1", :quantity => 2, :type => "global_ipv4", :comments => "test comment")

Available parameters

Retrives the list of IP addresses under the specified project

response = compute.ips.all(project_id)

Optional parameters

Assigns an IP address to the specified servers

response = ip.assign(server_id)

Unassigns the specified IP address

response = compute.unassign

Creates a new project

response = compute.projects.create(:name => "test01", :payment_method_id => "1234")

Available parameters

Gets project details

response = compute.projects.get(project_id)

List all available plans of the account

response = compute.plans.all

Optional parameters

List all available facilities of the account

response = compute.facilities.all

Optional parameters

List all users in the current user’s projects

response = compute.users.all

Optional parameters

Retrieve the currently logged-in user or retrieve a user by user ID.

response = compute.users.get

response = compute.users.get(user_id)

Updates user information.

user.first_name = "Jane"
user.last_name = "Doe"

response = user.update

Available parameters

Add a new email address to the current user.

email = compute.emails.create(:address => "jdoe@example.net", :default => false)

Available parameters

Provides one of the user’s emails.

response = compute.emails.get(email_id)

Updates the email.

email.default = false
email.update

Available parameters

Deletes the email.

response = email.destroy

Note: Default email cannot be deleted.

Turns on vpn for the currently logged-in user.

response = compute.vpns.enable

Turns off vpn for the currently logged-in user.

response = compute.vpns.disable

Returns the client vpn config for the currently logged-in user.

response = compute.vpns.get("nrt1")

Available parameters

Get Packet current spot market prices.

response = compute.spot_market_prices.all

Get spot market prices for a given plan and facility in a fixed period of time.

response = compute.spot_market_prices.get("ewr1", "baremetal_0")

Available parameters

Creates a SSH Key

response = compute.ssh_keys.create(:label => "test", :key => "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDgnV5MOhBqpQLt66KGlMKi...")

Available parameters

Returns a collection of the current user SSH keys. The UUIDs are used with the device.create user_ssh_keys property.

response = compute.ssh_keys.all

The following example returns a collection of the project SSH keys. These UUIDs are used with the device.create project_ssh_keys property.

response = compute.ssh_keys.all(project_id)

Optional parameters

Returns a single ssh key

response = compute.ssh_keys.get(key_id)

sshkey.label = "test_jg_01"
sshkey.key = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDgnV5MOhBqpQLt66KGlMKi..."

response = sshkey.update

Available parameters

Deletes the ssh key.

response = sshkey.destroy

Creates a new batch of instances.

batches = [{
    :hostname => "test1",
    :description => "test batch",
    :plan => "baremetal_0",
    :operating_system => "coreos_stable",
    :facility => "ewr1",
    :billing_cycle => "hourly",
    :tags => ["abc"],
    :quantity => 1
}]

response = compute.batches.create(project_id, :batches => batches)

Available parameters

Returns all batches for the given project.

response = compute.batches.all(project_id)

Optional parameters

Returns a batch

response = compute.batches.get(batch_id)

Creates a BGP session.

response = compute.bgp_sessions.create(:device_id => server_id, :address_family => address_family)

Provides a listing of available BGP sessions for the server.

response = compute.bgp_sessions.all(server_id)

Returns a BGP session.

response = compute.bgp_sessions.get(session_id)

Deletes the BGP session

response = session.destroy

Enables two factor authentication using authenticator app.

compute.two_factor_auth.enable(type)

Disables two factor authentication.

compute.two_factor_auth.disable(type)

Log in

compute.sessions.login(:username => "username",:password => "password")

Returns all session tokens for the current user.

sessions = compute.sessions.all

Optional parameters

Destroy users current session unless sessions_id is provided.

compute.sessions.destroy(sessions_id)

Returns a collection of the current user’s notification.

compute.notifications.all

Optional parameters

Returns a single notification if the user has access.

compute.notifications.get(notification_id)

Updates a single notification. Currently, the only supported operation is marking a notification as read.

notification.update

Returns all invitations in a project.

compute.invitations.all(project_id)

Optional parameters

Returns a single invitation.

invite = compute.invitations.get(invite_id)

Accept an invitation.

invite.accept

Decline an invitation.

invite.decline

Creates an email verification request.

compute.email_verification.request(email)

Consumes an email verification token and verifies the user associated with it.

compute.email_verification.verify(token)

Creates a new license for the given project.

license = {
  :project_id => project_id, 
  :description => "test01", 
  :size => 1,
  :license_product_id => "license_product_id"
}

license = compute.licenses.create(license)

Provides a collection of licenses for a given project.

compute.licenses.all(project_id)

Optional parameters

Returns a license.

license = compute.licenses.get(license_id)

Returns all memberships in a project.

memberships = compute.memberships.all(project_id)

Optional parameters

Returns a single membership.

membership = compute.memberships.get(membership_id)

Updates the membership.

membership.roles = ["owner"]
membership.update

Deletes the membership.

membership.destroy

Creates an organization.

options = {
  :name => "test_org",
  :description => "test organization"
}

response = compute.organizations.create(options)

Available parameters

Updates the organization.

org.name = "new name"
org.description = "new organization"

response = org.update

Returns a single organization's details, if the user is authorized to view it.

org = compute.organizations.get(org_id)

Returns a list of organizations that are accessible to the current user.

response = compute.organizations.all

Optional parameters

Deletes the organization.

response = org.destroy

Returns a list of facilities and plans with their current capacity.

response = compute.capacities.all

Validates if a deploy can be fulfilled.

options = {
  :servers => [
    {
      :facility => "ewr1",
      :plan => "baremetal_2a",
      :quantity => 1
    },
    {
      :facility => "atl1",
      :plan => "baremetal_1e",
      :quantity => 1
    }
  ]
}

response = compute.capacities.validate(options)

If required capacities are available function will return true otherwise it will return an error with details.

Creates a payment method.

options = {
    :name => "test",
    :default => "false",
    :nonce => "12",
    :organization_id => "ef114acb-2e50-43b5-83e7-b7c2758f0520"
}

response = compute.payment_methods.create(options)

Available parameters

Returns all payment methods of an organization.

payment_methods = compute.payment_methods.all(org_id)

Optional parameters

Returns a payment method.

payment_method = compute.payment_methods.get(payment_method_id)

Updates the payment method.

payment_method.name = "new name"
payment_method.expiration_month = 12
payment_method.expiration_year = 2022
response = payment_method.update

Deletes the payment method.

response = payment_method.destroy

Organization owners can transfer their projects to other organizations.

response = compute.transfer_requests.transfer(project_id, org_id)

Available parameters

Provides a collection of project transfer requests from or to the organization.

response = compute.transfer_requests.all(org_id)

Optional parameters

Returns a single transfer request.

transfer_request = compute.transfer_requests.get(transfer_request_id)

Accept a transfer request.

response = transfer_request.accept

Decline a transfer request.

response = transfer_request.decline

Provides a collection of hardware reservations for a given project.

hardware_reservations = compute.hardware_reservations.all(project_id)

Optional parameters

Returns a single hardware reservation.

hardware_reservation = @compute.hardware_reservations.get(reservation_id)

Move a hardware reservation to another project.

hardware_reservation.move(project_id) 

Run mock tests:

FOG_MOCK=true rake test

Run real tests:

FOG_MOCK=false rake test

For help with this package:

• Open up a GitHub issue here.
• Contact the Packet Community Slack or on Freenode IRC in the #packethost channel.
• Search the Packet Help Center.