knife-google 1.3.1 → 2.0.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZTFlMWVhYzJkYjU0NmRhNGFmNThmZmQwZjc2Y2JlYmZkMzMxMDc5Yw==
-  data.tar.gz: !binary |-
-    ODk4M2I4ODEwYjkwNzg3ODI4ZTIzNmM1NDllMWNhNmU2MmE0OTI0Nw==
+SHA1:
+  metadata.gz: 99ff46ae852794142abaae910482f89dd799b057
+  data.tar.gz: 2e76ef1b04265a9271a7664a2cd9488eb74c357b
 SHA512:
-  metadata.gz: !binary |-
-    NDBiZDgyMGU4NmIzNTAzNmFiYmVjODg2ZGJlNzZiNTBmNzJhODlhOTk3NWE3
-    NTA0ZTI4NzZmOTIzMTFhZGMzNzIwY2RlYTIzMmUxNTA2ZjViZDAxZjUwZDM5
-    NTg0MjQ2YzIxZGVhMzY5N2YzZDNmYTExNThlZDM4YmMyOTI2NjM=
-  data.tar.gz: !binary |-
-    MjQ0MDU5YmUyYjFlYWVlNTJkYzQyOTcxZjY0M2M2N2MxZDJkNzJjYzBkMDc4
-    MGZjODIyYjA4M2M4NDBiNTQ2OGI0YWZkYjE3NTQwNTA4MGI3ZTk0YTZhMjky
-    ODkzY2Q0YzhjNWI4NDQwNDRmMGQzNjY1MzY3NDE1NjFmOWJmNTc=
+  metadata.gz: 98d48fa470acd31b44a668c15ea2a35026bf87a047ee3ac6faf415556fc379a3d22ca687c1ca317727d0df9d45c48688b38c8ef66cfabdcf10fab4e5c19cfd2e
+  data.tar.gz: 3731acd0adf71b71771a36568d452e8bf817cb9b69d30fbcfd7fb16487f3ead978bff21f627e7a594fd20086c1f999fe0de4fd20fb54103fcd99cb56ec8115e2

data/.gitignore

@@ -20,3 +20,4 @@ doc/
 .swo
 Gemfile.lock
 .rvmrc
+.ruby-version

data/.travis.yml

@@ -1,4 +1,16 @@
+language: ruby
+cache: bundler
+sudo: false
 rvm:
-  - 1.9.3
-
-script: bundle exec rake spec
+- 2.0.0
+- 2.1
+- 2.2
+branches:
+  only:
+  - master
+notifications:
+  slack:
+    on_success: change
+    on_failure: always
+    rooms:
+      secure: ml+Ph8FuoU4TgEqGmjERaF5peoNTRhllG5rBFDUgGxPCKRxE9snYDwc+29RAhA7izlaUABIA3fWT11SdF2RMTUorsrz0PbYtyBZuI9AKloww1CUFMl2kr8+DRt/AzMcGYs8OgQW12NLNNRV72X4wUKsJXpazVHsXctU/Fh/AqX0=

data/CHANGELOG.md

@@ -1,14 +1,12 @@
 # knife-google Change Log
 
-## Unreleased: 
+## v2.0.0 (2016-03-01)
+ * [pr#94](https://github.com/chef/knife-google/pull/94) Full rewrite using knife-cloud, newer Google API client library, Windows instance support, and better user feedback.
 
-None
-
-## Last Release 1.3.1 (04/24/2014)
+## v1.3.1 (04/24/2014)
 
 * Refresh access token (KNIFE-473)
 
-
-## Release: 1.2.0 (02/17/2014)
+## v1.2.0 (02/17/2014)
 
 See source control commit history for earlier changes.

data/Gemfile

@@ -1,11 +1,5 @@
-source 'https://rubygems.org'
-
-group(:development, :test) do
-  platforms :mswin, :mingw do
-     gem "ffi", "1.3.1"
-     gem "rdp-ruby-wmi", "0.3.1"
-     gem "win32-service", "0.7.2"
-  end
-end
+source "https://rubygems.org"
 
 gemspec
+
+gem "chefstyle", git: "https://github.com/chef/chefstyle"

data/README.md

@@ -1,414 +1,267 @@
 # knife-google
 
-A [knife] (http://wiki.opscode.com/display/chef/Knife) plugin to create,
-delete and enlist
-[Google Compute Engine] (https://cloud.google.com/products/compute-engine)
+[![Gem Version](https://badge.fury.io/rb/knife-google.svg)](http://badge.fury.io/rb/knife-google)
+[![Build Status](https://travis-ci.org/chef/knife-google.svg?branch=master)](https://travis-ci.org/chef/knife-google)
+[![Dependency Status](https://gemnasium.com/chef/knife-google.svg)](https://gemnasium.com/chef/knife-google)
+
+A plugin for Chef's [knife](https://docs.chef.io/knife.html) tool to create and manage
+[Google Compute Engine](https://cloud.google.com/products/compute-engine)
 resources.
 
-## Overview
+# Getting Started
 
-This plugin adds functionality to Chef through a knife plugin to create,
-delete, and manage
-[Google Compute Engine](https://cloud.google.com/products/compute-engine)
-servers and disks.
+## Install the gem
 
-### Compatibility
+Install the gem with:
 
-This plugin utilizes Google Compute Engine API v1. Please review API v1
-[release notes](https://developers.google.com/compute/docs/release-notes#december032013)
-for additional information.
+```sh
+gem install knife-google
+```
 
-With knife-google 1.3.0 options have changed. Several GCE specific short
-options have been deprecated and GCE specific long options now start
-with '--gce-'.
+Or, even better, if you're using the ChefDK:
 
-### Nomenclature
+```sh
+chef gem install knife-google
+```
 
-This plugin conforms to the nomenclature used by similar plugins and uses
-the term "server" when referencing nodes managed by the plugin.  In
-Google Compute Engine parlance, this is equivalent to an "instance" or
-"virtual machine instance".
+If you're using Bundler, simply add it to your Gemfile:
 
-### Create a Google Cloud Platform project
+```ruby
+gem "knife-google", "~> 2.0"
+```
+
+... and then run `bundle install`.
+
+## Create a Google Cloud Platform project
 
 Before getting started with this plugin, you must first create a
-[Google Cloud Platform](https://cloud.google.com/) "project" and add the
-Google Compute Engine service to your project.  Once you have created your
-project, you will have access to other Google Cloud Platform services such as
-[App Engine](https://developers.google.com/appengine/),
-[Cloud Storage](https://developers.google.com/storage/),
-[Cloud SQL](https://developers.google.com/cloud-sql/)
-and others, but this plugin only requires you enable Google Compute Engine in
-your project.  Note that you will need to be logged in with your Google
-Account before creating the project and adding services.
-
-### Authorizing Setup
-
-In order for the knife plugin to programmatically manage your servers, you
-will first need to authorize its use of the Google Compute Engine API.
-Authorization to use any of Google's Cloud service API's utilizes the
-[OAuth 2.0](https://developers.google.com/accounts/docs/OAuth2) standard.
-Once your project has been created, log in to your Google Account and visit the
-[API Console](http://code.google.com/apis/console) and follow the "API Access"
-menu.  Create a new "Client ID" and specify the
-[Installed Application](https://developers.google.com/accounts/docs/OAuth2#installed)
-Application type with sub-type "Other".  These actions will generate a new
-"Client ID", "Client secret", and "Redirect URI's".
-
-This knife plugin includes a 'setup' sub-command that requires you to supply
-the client ID and secret in order to obtain an "authorization token".  You
-will only need to run this command one time and the plugin will record your
-credential information and tokens for future API calls.
-
-## Installation
-
-Be sure you are running Chef version 0.10.0 or higher in order to use knife
-plugins.
+[Google Cloud Platform](https://cloud.google.com/) (GCP) "project" and add the
+Google Compute Engine service to your project.  While GCP has many other services,
+such as App Enging and Cloud Storage, this plugin only provides an integration with
+Google Compute Engine (GCE). 
+
+## Authentication and Authorization
+
+The [underlying API](https://github.com/google/google-api-ruby-client) this plugin uses relies on the 
+[Google Auth Library](https://github.com/google/google-auth-library-ruby) to handle authentication to the
+Google Cloud API. The auth library expects that there is a JSON credentials file located at:
+
+`~/.config/gcloud/application_default_credentials.json`
+
+The easiest way to create this is to download and install the [Google Cloud SDK](https://cloud.google.com/sdk/) and run the
+`gcloud auth login` command which will create the credentials file for you.
+
+If you already have a file you'd like to use that is in a different location, set the `GOOGLE_APPLICATION_CREDENTIALS` environment variable with the full path to that file
+
+##  Configuration
+
+All knife-google commands require a project name and zone name to be supplied. You can supply these on the command line:
 
 ```sh
-    gem install knife-google
+knife google server list --gce-project my-test-project --gce-zone us-east1-b
 ```
 
-or, for Gemfile:
+... or you can set them in your `knife.rb` file:
 
 ```ruby
-    gem 'knife-google'
+knife[:gce_project] = 'my-test-project'
+knife[:gce_zone]    = 'us-east1-b'
 ```
 
-There is a long standing issue in Ruby where the net/http library by default
-does not check the validity of an SSL certificate during a TLS handshake.
+## SSH Keys
+
+In order to Linux bootstrap nodes, you will first need to ensure your SSH
+keys are set up correctly. Ensure your SSH public key is properly entered 
+into your project's Metadata tab in the GCP Console. 
+
+You can find [more information on configuring SSH keys](https://cloud.google.com/compute/docs/instances/adding-removing-ssh-keys) in
+the Google Compute Engine documentation.
+
+# Usage
+
+To see all knife-google commands, run: `knife google`
+
+All commands have additional help output. Simply append `--help` to any command. 
+For example, to see additional help and flags available for the `knife google disk create` command,
+run: `knife google disk create --help`
+
+## knife google disk create DISKNAME
 
-To configure Windows system to validate SSL certificate please download
-[cacert.pem](http://curl.haxx.se/ca/cacert.pem) file and save to C: drive.
-Now make ruby aware of your certificate authority by setting SSL_CERT_FILE.
+Create a disk in GCE.
 
-To set this in your current command prompt session, type:
+### Parameters
+
+ * **DISKNAME**: required. The name of the disk to create.
+ * **gce-disk-size**: optional. The size of the disk, in GB, to create. Valid options are between 10 and 10,000. The default is 10.
+ * **gce-disk-type**: optional. The type of GCE disk to create, such as `pd-ssd`. Default is `pd-standard`.
+ * **gce-disk-source**: optional. Image to use when creating a disk. By default, the disk will be created blank.
+
+### Example
 
 ```sh
-    set SSL_CERT_FILE = C:\cacert.pem
+knife google disk create my-test-disk --gce-disk-type pd-ssd --gce-disk-size 50
 ```
 
-On Linux system the configuration for SSL certificate validation is present by default.
+## knife google disk delete DISKNAME [DISKNAME]
 
-Depending on your system's configuration, you may need to run this command
-with root/Administrator privileges.
+Deletes one or more disks from GCE.
 
-##  Configuration
+### Parameters
+
+ * **DISKNAME**: required. The name of the disk to delete. You can specify more than one disk to delete at a time.
 
-### Setting up the plugin
-
-For initial setup, you must first have created your Google Cloud Platform
-project, enabled Google Compute Engine, and set up the Client ID described
-above.  Run the 'setup' sub-command and supply the Project ID, the Client
-ID, Client secret, and authorization tokens when prompted. It will also
-prompt you to open a URL in a browser. Make sure sure the you are logged
-in with the Google account associated with the project and client
-id/secrete in order to authorize the plugin.
-
-  ```sh
-  knife google setup
-  ```
-
-By default, the credential and token information will be stored in
-`~/.google-compute.json`.  You can override this location with
-`-f <credential_file>` flag with all plugin commands.
-
-### Bootstrap Preparation and SSH
-
-In order to bootstrap nodes, you will first need to ensure your SSH
-keys are set up correctly.  In Google Compute Engine, you can store
-SSH keys in project metadata that will get copied over to new servers
-and placed in the appropriate user's `~/.ssh/authorized_keys` file.
-
-If you don't already have SSH keys set up, you can create them with
-the `ssh-keygen` program.  Open up the Metadata page from the
-GCE section of the cloud console.  If it doesn't already exist, create
-a new `sshKeys` key and paste in your user's `~/.ssh/id_rsa.pub`
-file; make sure to prefix the entry with the username that corresponds
-to the username specified with the `-x` (aka `--ssh-user`) argument of the knife 
-command or its default value of `root`.  An example entry should look
-something like this -- notice the prepended username of `myuser`:
-
-  ```
-  myuser:ssh-rsa AYAAB3Nwejwejjfjawlwl990sefjsfC5lPulcP4eZB+z1zcMF
-  76gTV4vojT/SWXymTfGpBL2KHTmF4jnGfEKPwjHIiLrZNHM2ISMi/atlKjOoUCVT
-  AvUyjqqp3z2KVXSP9P50Kgf8JYWjjXKApiZHkJOHJZ8GGf7aTnRU9NEGLbQK6Q1k
-  4UHbVG4ps4kSLWsJ7eVcu981GvlwP3ooiJ6YWcOX9PS58d4SNtq41/XaoLibKt/Y
-  Wzd/4tjYwMRVcxJdAy1T2474vkU/Qr7ibFinKeJymgouoQpEGhF64cF2pncCcmR7
-  zRk7CzL3mhcma8Zvwj234-2f3/+234/AR#@R#y1EEFsbzGbxOJfEVSTgJfvY7KYp
-  329df/2348sd3ARTx99 mymail@myhost
-  ```
-
-## Usage
-
-Some usage examples follow:
-
-  ```sh
-  # See a list of all zones, their statuses and maintenance windows
-  $ knife google zone list
-
-  # List all servers (including those that may not be managed by Chef)
-  $ knife google server list -Z us-central1-a
-
-  # Create a server
-  $ knife google server create www1 -m n1-standard-1 -I debian-7-wheezy-v20131120 -Z us-central1-a -i ~/.ssh/id_rsa -x jdoe
-
-  # Create a server with service account scopes
-  $ knife google server create www1 -m n1-standard-1 -I debian-7-wheezy-v20131120 -Z us-central1-a -i ~/.ssh/id_rsa -x jdoe --gce-service-account-scopes https://www.googleapis.com/auth/userinfo.email,https://www.googleapis.com/auth/compute,https://www.googleapis.com/auth/devstorage.full_control
-
-  # Delete a server (along with Chef node and API client via --purge)
-  $ knife google server delete www1 --purge -Z us-central1-a
-  ```
-
-For a full list of commands, run `knife google` without additional arguments:
-
-  ```sh
-  $ knife google
-
-  ** GOOGLE COMMANDS **
-  knife google disk create NAME --gce-disk-size N -Z ZONE (options)
-  knife google disk delete NAME -Z ZONE (options)
-  knife google disk list -Z ZONE (options)
-  knife google project list (options)
-  knife google region list (options)
-  knife google server create NAME -m MACHINE_TYPE -I IMAGE -Z ZONE (options)
-  knife google server delete SERVER [SERVER] -Z ZONE (options)
-  knife google server list -Z ZONE (options)
-  knife google setup
-  knife google zone list (options)
-  ```
-
-More detailed help can be obtained by specifying sub-commands.  For
-instance,
-
-  ```sh
-  $ knife google server list -Z us-central1-a --help
-  knife google server list -Z ZONE (options)
-    -s, --server-url URL             Chef Server URL
-        --chef-zero-port PORT        Port to start chef-zero on
-    -k, --key KEY                    API Client Key
-        --[no-]color                 Use colored output, defaults to false on Windows, true otherwise
-    -f CREDENTIAL_FILE,              Google Compute credential file (google setup can create this)
-        --gce-credential-file
-    -c, --config CONFIG              The configuration file to use
-        --defaults                   Accept default values for all questions
-    -d, --disable-editing            Do not open EDITOR, just accept the data as is
-    -e, --editor EDITOR              Set the editor to use for interactive commands
-    -E, --environment ENVIRONMENT    Set the Chef environment
-    -F, --format FORMAT              Which format to use for output
-    -z, --local-mode                 Point knife commands at local repository instead of server
-    -u, --user USER                  API Client Username
-        --print-after                Show the data after a destructive operation
-    -V, --verbose                    More verbose output. Use twice for max verbosity
-    -v, --version                    Show chef version
-    -y, --yes                        Say yes to all prompts for confirmation
-    -Z, --gce-zone ZONE              The Zone for this server (required)
-    -h, --help                       Show this message
-  ```
-
-## Sub-commands
-
-### knife google setup
-
-Use this command to initially set up authorization (see above for more
-details).  Note that if you override the default credential file with the
-`-f` switch, you'll need to use the `-f` switch for *all* sub-commands.
-When prompted, make sure to specify the "Project ID" (and not the name or
-number) or you will see 404/not found errors even if the setup command
-completes successfully.
-
-### knife google zone list
-
-A zone is an isolated location within a region that is independent of
-other zones in the same region. Zones are designed to support instances
-or applications that have high availability requirements. Zones are
-designed to be fault-tolerant, so that you can distribute instances
-and resources across multiple zones to protect against the system
-failure of a single zone. This keeps your application available even
-in the face of expected and unexpected failures. The fully-qualified
-name is made up of `<region>/<zone>`. For example, the fully-qualified
-name for zone `a` in region `us-central1` is `us-central1-a`. Depending on
-how widely you want to distribute your resources, you may choose to
-create instances across multiple zones within one region or across
-multiple regions and multiple zones.
-
-Use this command to list out the available Google Compute Engine zones.
-You can find a zone's current status and upcoming maintenance windows.
-
-The output for `knife google zone list` should look similar to:
-
-  ```
-  name            status  deprecation  maintainance window
-  europe-west1-a  up      -            2014-01-18 12:00:00 -0800 to 2014-02-02 12:00:00 -0800
-  europe-west1-b  up      -            2014-03-15 12:00:00 -0700 to 2014-03-30 12:00:00 -0700
-  us-central1-a   up      -            -
-  us-central1-b   up      -            -
-  ```
-
-### knife google region list
-
-Each region in Google Compute Engine contains any number of zones.
-The region describes the geographic location where your resources
-are stored. For example, a zone named `us-east1-a` is in region `us-east1`.
-A region contains one or more zones.
-
-Choose a region that makes sense for your scenario. For example, if you
-only have customers on the east coast of the US, or if you have specific
-needs that require your data to live in the US, it makes sense to store
-your resources in a zone with a us-east region.
-
-Use this command to list out the available Google Compute Engine regions.
-You can find the region's current status, cpus, disks-total-gb,
-in-use-addresses and static-addresses. Use the `-L` switch to also list
-the quota limit for each resource.
-
-The output for `knife google region list -L` should look similar to:
-
-  ```
-  Name          status  deprecation  cpus  disks-total-gb  in-use-addresses  static-addresses
-  europe-west1  up      -            1/10  100/100000      1/10              1/7
-  us-central1   up      -            0/10  0/100000        0/10              0/7
-  us-central2   up      -            1/10  50/100000       1/10              1/7
-  ```
-
-### knife google project list
-
-A project resource is the root collection and settings resource for
-all Google Compute Engine resources.
-
-Use this command to list out your project's current usage of snapshots,
-networks, firewalls, images, routes, forwarding-rules, target-pools and
-health-checks. Use the `-L` switch to also list the quota limit for
-each resource.
-
-The output for `knife google project list -L` should look similar to:
-
-  ```
-  name          status  deprecation  cpus  disks-total-gb  in-use-addresses  static-addresses
-  europe-west1  up      -            0     0               0                 0
-  us-central1   up      -            100   1000            10                1
-  us-central2   up      -            0     0               0                 0
-  ```
-
-### knife google server create
-
-Use this command to create a new Google Compute Engine server (a.k.a.
-instance) with a persistent boot disk. You must specify a name, the
-machine type, the zone, and the the image name. Images provided by
-Google follow this naming convention:
-
-  ```
-  debian-7-wheezy-vYYYYMMDD
-  centos-6-vYYYYMMDD
-  ```
-
-By default, the plugin will look for the specified image in the instance's
-primary project first and then consult GCE's officially supported image
-locations. The `--gce-image-project-id IMAGE_PROJECT_ID` option can be 
-specified to force the plugin to look for the image in an alternate project
-location.
+### Example
 
-Note that if you are bootstrapping the node, make sure to follow the 
-preparation instructions earlier and use the `-x` and `-i` commands 
-to specify the username and the identity file for that user.  Make sure 
-to use the private key file (e.g. `~/.ssh/id_rsa`) for the identity 
-file and *not* the public key file.
+```sh
+knife google disk delete my-test-disk1 my-test-disk2
+```
 
-If you would like to set up your server with a service account, provide
-the --gce-service-account-scopes argument during server creation. The service
-account associated with your project will be used by default unless otherwise
-specified with the optional --gce-service-account-name argument.
+## knife google disk list
 
-See the extended options that also allow bootstrapping the node with
-`knife google server create --help`.
+List all disks in the currently-configured GCE project and zone.
 
-### knife google server delete
+### Parameters
 
-This command terminates and deletes a server.  Use the `--purge`
-option to also remove it from Chef.
+None.
 
-Note that persistent disks associated with the server, including the
-boot disk, are not deleted with this operation. To delete persistent
-disks use `knife google disk delete`.
+## knife google project quotas
 
-Use `knife google server delete --help` for other options.
+Display all project resources and quotas for the currently-configured project, such as the number of snapshots allowed and currently consumed.
 
-### knife google server list
+### Parameters
 
-Get a list of servers in the specified zone.  Note that this may
-include servers that are *not* managed by Chef. Your output should
-look something like:
+None.
 
-  ```
-  name              type             public ip        private ip      disks               zone           status
-  chef-server       n1-standard-1    103.59.80.113    10.240.45.78    chef-server         us-central1-a  running
-  chef-workstation  n1-standard-1    103.59.85.188    10.240.9.140    chef-workstation    us-central1-a  running
-  fuse-dev          n1-standard-1    103.59.80.147    10.240.166.18   fuse-dev            us-central1-a  running
-  magfs-c1          n1-standard-2    103.59.87.217    10.240.61.92    magfs-c1            us-central1-a  running
-  magfs-c2          n1-standard-2    103.59.80.161    10.240.175.240  magfs-c2            us-central1-a  running
-  magfs-c3          n1-standard-2    178.255.120.69   10.240.34.197   magfs-c3            us-central1-a  running
-  magfs-svr         n1-standard-4    103.59.80.178    10.240.81.25    magfs-svr           us-central1-a  running
-  ```
+## knife google region list
 
-### knife google disk create
+Display all regions available to the currently-configured project, what each region's status is, and what zones exist in each region.
 
-Create a new persistent disk. You must provide a name, size in
-gigabytes, and the desired zone.
+### Parameters
 
-### knife google disk delete
+None.
 
-Delete an existing disk in the specified zone. Note that the
-disk will *not* be deleted if it is currently attached to a
-running server.
+## knife google region quotas
 
-### knife google disk list
+Display all resources and quotas for all regions in the currently-configured project, such as how many instances are allowed and currently configured in a given region.
 
-See a listing of disks defined for a specific zone. Your output should
-look something like:
+### Parameters
 
-  ```
-  name              zone            source snapshot   size (in GB)   status
-  dev-1             us-central1-a                     10             ready 
-  dev-2             us-central1-a                     10             ready 
-  test-1            us-central1-a                     20             ready 
-  ```
+None.
 
-## Troubleshooting
+## knife google server create INSTANCE_NAME
 
- * Seeing 404 errors or zone not found?
-   This can result if you mistakenly specified an invalid "Project ID"
-   while going through the `knife google setup` command.  Make sure
-   you specified the "Project ID" (not the project name or number).
+Create a GCE server instance and bootstrap it with Chef.
 
-## Build and Development
+### Parameters
 
-Standard rake commands for building, installing, testing, and uninstalling the module.
+ * **INSTANCE_NAME**: required. The name to use when creating the instance.
+ * **--gce-machine-type**: required. The machine type to use when creating the server, such as `n1-standard-2` or `n1-highcpu-2-d`.
+ * **--gce-network**: The name of the network to which your instance will be attached. Defaults to "default".
+ * **--gce-image**: required. The name of the disk image to use when creating the server. knife-google will search your current project for this disk image. If the image cannot be found but looks like a common public image, the public image project will be searched as well.
+    * Example: if you supply a gce-image of `centos-7-v20160219`, knife-google will first look for an image with that name in your currently-configured project. If it cannot be found, it will look in the `centos-cloud` project.
+    * This behavior can be overridden with the `--gce-image-project` parameter.
+ * **--gce-image-project**: optional. The name of the GCP project that contains the image specified with the `--gce-image` flag. If this is specified, knife-google will not search any known public projects for your image.
+ * **--gce-boot-disk-name**: The name to use when creating the instance's boot disk. Defaults to the instance name.
+ * **--gce-boot-disk-size**: The size of the boot disk to create, in GB. Defaults to 10.
+ * **--[no-]gce-boot-disk-ssd**: If true, the boot disk will be created as a `pd-ssd` disk type. By default, this is false, and the boot disk will be created as a `pd-standard` disk type.
+ * **--[no-]gce-boot-disk-autodelete**: If true, the boot disk will be automatically deleted whenever the instance is deleted. Defaults to true.
+ * **--additional_disks**: A comma-separated list of disk names to attach to the instance when creating it. The disks must already exist.
+ * **--[no-]gce-auto-server-restart**: If true, the instance will be automatically restarted if it was terminated for non-user-initiated actions, such as host maintenance. Defaults to true.
+ * **--[no-]gce-auto-server-migrate**: If true, the instance will be automatically migrated to another host if maintenance would require the instance to be terminated. Defaulst to true.
+ * **--[no-]gce-can-ip-forward**: If true, the instance will be allowed to perform network forwarding. Defaults to false.
+ * **--gce-tags**: A comma-separated list of tag values to add to the instance.
+ * **--gce-metadata**: A comma-separated list of key=value pairs to be added to the instance metadata. Example: `--gce-metadata mykey=myvalue,yourkey=yourvalue`
+ * **--gce-service-account-scopes**: A comma-separated list of account scopes for this instance. View a list of scoped by running `gcloud compute instances create --help` and searching for the documentation for the `--scopes` parameter. You must supply the full URI (i.e. "https://www.googleapis.com/auth/devstorage.full_control") or the final part of the URI (i.e. "devstorage.full_control"). Alias names (i.e. "storage-rw") are not permitted.
+ * **--gce-service-account-name**: the service account name to use when adding service account scopes. This usually looks like an email address and can be created in the Permissions tab of the Google Cloud Console. Defaults to "default"
+ * **--gce-use-private-ip**: If true, Chef will attempt to bootstrap the device using the private IP rather than the public IP. Defaulst to false.
+ * **--gce-public-ip**: The type of public IP to associate with this instance. If "ephemeral", an ephemeral IP will be assigned. If "none", no public IP will be assigned. If a specific IP address is provided, knife-google will attempt to attach that specific IP address to the instance. Default is "ephemeral".
+ * **--gce-email**: required when creating and bootstrapping Microsoft Windows instances. The email address of the currently-logged-in Google Cloud user. This is required when resetting the Windows instance's password.
 
-  ```
-  # Run spec tests
-  $ rake
+Additionally, all the normal `knife bootstrap` flags are supported. See the output of `knife bootstrap --help` and `knife google server create --help` for additional information.
 
-  # Build and install the module
-  $ rake install
-  
-  # Uninstall
-  $ rake uninstall
-  ```
+### Example
 
-## Versioning and Release Protocol
+```sh
+knife google server create test-instance-1 --gce-image centos-7-v20160219 --gce-machine-type n1-standard-2 --gce-public-ip ephemeral --ssh-user myuser --identity-file /Users/myuser/.ssh/google_compute_engine
+```
+
+## knife google server delete INSTANCE_NAME [INSTANCE_NAME]
+
+Deletes one or more GCE server instance. Additionally, if requested, the client and node object for the given instance will be deleted off of the Chef Server as well.
+
+### Parameters
+
+ * **INSTANCE_NAME**: required. The name of the GCE instance to delete. You may provide more than one instance to delete.
+ * **--purge**: optional. If provided, the instances' client and node objects will be deleted off the Chef Server. Default is NOT to delete the objects.
+
+### Example
+
+```sh
+knife google server delete my-instance-1 my-instance-2 --purge
+```
+
+## knife google server list
+
+Display the instances in the currently-configured project and zone, their statuses, machine types, IP addresses, and network.
+
+### Parameters
+
+None.
+
+## knife google server show INSTANCE_NAME
+
+Display information about a single GCE instance, including its status, machine type, IP addresses, and network. Only one server may be displayed at a time.
+
+### Parameters
+
+ * **INSTANCE_NAME**: required. The name of the instance to show.
+
+## knife google zone list
+
+List all available zones in the currently-configured project and what each zone's status is.
+
+### Parameters
+
+None.
+
+## Bootstrapping Windows Nodes
+
+WinRM is used by Chef to bootstrap Windows nodes. The default settings of the GCE Windows images and GCP projects are not conducive to successful bootstrapping. Therefore, you will likely need to make some changes to your project settings and create your own image based on your company's policies. Some settings you will likely have to change include:
+
+ * inbound firewall rule in the GCP console to allow inbound WinRM (such as port 5985/tcp)
+ * inbound firewall rule in Windows Firewall to allow the inbound WinRM connections
+ * enable the appropriate WinRM transports
+
+# License and Authors
+
+Version 3.0.0 of knife-google was rewritten by Chef Partner Engineering but is largely inspired by initial versions of knife-google, thanks to the work of the great folks at Google.
+
+Author:: Chef Partner Engineering (<partnereng@chef.io>)
+
+Copyright:: Copyright (c) 2016 Chef Software, Inc.
+
+License:: Apache License, Version 2.0
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the License at
+
+```
+http://www.apache.org/licenses/LICENSE-2.0
+```
 
-Knife-google is released by the maintainer of this source repository to the gem
-repository at [RubyGems](https://rubygems.org). Releases are versioned
-according to [SemVer](http://semver.org) as much as possible, with a specific
-provision for GCE API changes:
+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.
 
-* When the implementation of knife-google switches to a new GCE API revision,
-  the minor version **MUST** be incremented.
+# Contributing
 
-The version number of the release is simply the gem version. All releases to RubyGems **MUST** be tagged in git with the version number of the release.
+We'd love to hear from you if you find this isn't working for you. Please submit a GitHub issue with any problems you encounter.
 
-## Contributing
-  * See [CONTRIB.md](https://github.com/opscode/knife-google/blob/master/CONTRIB.md)
+Additionally, contributions are welcome!  If you'd like to send up any fixes or changes:
 
-## Licensing
-  * See [LICENSE](https://raw.github.com/opscode/knife-google/master/LICENSE)
+1. Fork it ( https://github.com/chef/knife-google/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