diff --git a/builtin/providers/aws/resource_aws_instance.go b/builtin/providers/aws/resource_aws_instance.go
index 28c7b79e7..6be87e9b7 100644
--- a/builtin/providers/aws/resource_aws_instance.go
+++ b/builtin/providers/aws/resource_aws_instance.go
@@ -3,6 +3,7 @@ package aws
 import (
 	"bytes"
 	"crypto/sha1"
+	"encoding/base64"
 	"encoding/hex"
 	"fmt"
 	"log"
@@ -258,7 +259,7 @@ func resourceAwsInstanceCreate(d *schema.ResourceData, meta interface{}) error {
 	// Figure out user data
 	userData := ""
 	if v := d.Get("user_data"); v != nil {
-		userData = v.(string)
+		userData = base64.StdEncoding.EncodeToString([]byte(v.(string)))
 	}
 
 	placement := &ec2.Placement{
diff --git a/builtin/providers/aws/resource_aws_instance_test.go b/builtin/providers/aws/resource_aws_instance_test.go
index f85928cc5..e5f460954 100644
--- a/builtin/providers/aws/resource_aws_instance_test.go
+++ b/builtin/providers/aws/resource_aws_instance_test.go
@@ -411,7 +411,7 @@ resource "aws_instance" "foo" {
 
 	instance_type = "m1.small"
 	security_groups = ["${aws_security_group.tf_test_foo.name}"]
-	user_data = "foo"
+	user_data = "foo:-with-character's"
 }
 `
 
diff --git a/builtin/providers/aws/resource_aws_vpc.go b/builtin/providers/aws/resource_aws_vpc.go
index f4ac2162e..df7feb5a0 100644
--- a/builtin/providers/aws/resource_aws_vpc.go
+++ b/builtin/providers/aws/resource_aws_vpc.go
@@ -5,9 +5,10 @@ import (
 	"log"
 	"time"
 
+	"github.com/hashicorp/aws-sdk-go/aws"
+	"github.com/hashicorp/aws-sdk-go/gen/ec2"
 	"github.com/hashicorp/terraform/helper/resource"
 	"github.com/hashicorp/terraform/helper/schema"
-	"github.com/mitchellh/goamz/ec2"
 )
 
 func resourceAwsVpc() *schema.Resource {
@@ -63,23 +64,26 @@ func resourceAwsVpc() *schema.Resource {
 }
 
 func resourceAwsVpcCreate(d *schema.ResourceData, meta interface{}) error {
-	ec2conn := meta.(*AWSClient).ec2conn
-
-	// Create the VPC
-	createOpts := &ec2.CreateVpc{
-		CidrBlock:       d.Get("cidr_block").(string),
-		InstanceTenancy: d.Get("instance_tenancy").(string),
+	ec2conn := meta.(*AWSClient).awsEC2conn
+	instance_tenancy := "default"
+	if v, ok := d.GetOk("instance_tenancy"); ok {
+		instance_tenancy = v.(string)
 	}
-	log.Printf("[DEBUG] VPC create config: %#v", createOpts)
-	vpcResp, err := ec2conn.CreateVpc(createOpts)
+	// Create the VPC
+	createOpts := &ec2.CreateVPCRequest{
+		CIDRBlock:       aws.String(d.Get("cidr_block").(string)),
+		InstanceTenancy: aws.String(instance_tenancy),
+	}
+	log.Printf("[DEBUG] VPC create config: %#v", *createOpts)
+	vpcResp, err := ec2conn.CreateVPC(createOpts)
 	if err != nil {
 		return fmt.Errorf("Error creating VPC: %s", err)
 	}
 
 	// Get the ID and store it
-	vpc := &vpcResp.VPC
-	log.Printf("[INFO] VPC ID: %s", vpc.VpcId)
-	d.SetId(vpc.VpcId)
+	vpc := vpcResp.VPC
+	d.SetId(*vpc.VPCID)
+	log.Printf("[INFO] VPC ID: %s", d.Id())
 
 	// Set partial mode and say that we setup the cidr block
 	d.Partial(true)
@@ -106,7 +110,7 @@ func resourceAwsVpcCreate(d *schema.ResourceData, meta interface{}) error {
 }
 
 func resourceAwsVpcRead(d *schema.ResourceData, meta interface{}) error {
-	ec2conn := meta.(*AWSClient).ec2conn
+	ec2conn := meta.(*AWSClient).awsEC2conn
 
 	// Refresh the VPC state
 	vpcRaw, _, err := VPCStateRefreshFunc(ec2conn, d.Id())()
@@ -120,34 +124,53 @@ func resourceAwsVpcRead(d *schema.ResourceData, meta interface{}) error {
 
 	// VPC stuff
 	vpc := vpcRaw.(*ec2.VPC)
-	d.Set("cidr_block", vpc.CidrBlock)
+	vpcid := d.Id()
+	d.Set("cidr_block", vpc.CIDRBlock)
 
 	// Tags
-	d.Set("tags", tagsToMap(vpc.Tags))
+	d.Set("tags", tagsToMapSDK(vpc.Tags))
 
 	// Attributes
-	resp, err := ec2conn.VpcAttribute(d.Id(), "enableDnsSupport")
+	attribute := "enableDnsSupport"
+	DescribeAttrOpts := &ec2.DescribeVPCAttributeRequest{
+		Attribute: aws.String(attribute),
+		VPCID:     aws.String(vpcid),
+	}
+	resp, err := ec2conn.DescribeVPCAttribute(DescribeAttrOpts)
 	if err != nil {
 		return err
 	}
-	d.Set("enable_dns_support", resp.EnableDnsSupport)
-
-	resp, err = ec2conn.VpcAttribute(d.Id(), "enableDnsHostnames")
+	d.Set("enable_dns_support", *resp.EnableDNSSupport)
+	attribute = "enableDnsHostnames"
+	DescribeAttrOpts = &ec2.DescribeVPCAttributeRequest{
+		Attribute: &attribute,
+		VPCID:     &vpcid,
+	}
+	resp, err = ec2conn.DescribeVPCAttribute(DescribeAttrOpts)
 	if err != nil {
 		return err
 	}
-	d.Set("enable_dns_hostnames", resp.EnableDnsHostnames)
+	d.Set("enable_dns_hostnames", *resp.EnableDNSHostnames)
 
 	// Get the main routing table for this VPC
-	filter := ec2.NewFilter()
-	filter.Add("association.main", "true")
-	filter.Add("vpc-id", d.Id())
-	routeResp, err := ec2conn.DescribeRouteTables(nil, filter)
+	// Really Ugly need to make this better - rmenn
+	filter1 := &ec2.Filter{
+		Name:   aws.String("association.main"),
+		Values: []string{("true")},
+	}
+	filter2 := &ec2.Filter{
+		Name:   aws.String("vpc-id"),
+		Values: []string{(d.Id())},
+	}
+	DescribeRouteOpts := &ec2.DescribeRouteTablesRequest{
+		Filters: []ec2.Filter{*filter1, *filter2},
+	}
+	routeResp, err := ec2conn.DescribeRouteTables(DescribeRouteOpts)
 	if err != nil {
 		return err
 	}
 	if v := routeResp.RouteTables; len(v) > 0 {
-		d.Set("main_route_table_id", v[0].RouteTableId)
+		d.Set("main_route_table_id", *v[0].RouteTableID)
 	}
 
 	resourceAwsVpcSetDefaultNetworkAcl(ec2conn, d)
@@ -157,20 +180,24 @@ func resourceAwsVpcRead(d *schema.ResourceData, meta interface{}) error {
 }
 
 func resourceAwsVpcUpdate(d *schema.ResourceData, meta interface{}) error {
-	ec2conn := meta.(*AWSClient).ec2conn
+	ec2conn := meta.(*AWSClient).awsEC2conn
 
 	// Turn on partial mode
 	d.Partial(true)
-
+	vpcid := d.Id()
+	modifyOpts := &ec2.ModifyVPCAttributeRequest{
+		VPCID: &vpcid,
+	}
 	if d.HasChange("enable_dns_hostnames") {
-		options := new(ec2.ModifyVpcAttribute)
-		options.EnableDnsHostnames = d.Get("enable_dns_hostnames").(bool)
-		options.SetEnableDnsHostnames = true
+		val := d.Get("enable_dns_hostnames").(bool)
+		modifyOpts.EnableDNSHostnames = &ec2.AttributeBooleanValue{
+			Value: &val,
+		}
 
 		log.Printf(
 			"[INFO] Modifying enable_dns_hostnames vpc attribute for %s: %#v",
-			d.Id(), options)
-		if _, err := ec2conn.ModifyVpcAttribute(d.Id(), options); err != nil {
+			d.Id(), modifyOpts)
+		if err := ec2conn.ModifyVPCAttribute(modifyOpts); err != nil {
 			return err
 		}
 
@@ -178,21 +205,22 @@ func resourceAwsVpcUpdate(d *schema.ResourceData, meta interface{}) error {
 	}
 
 	if d.HasChange("enable_dns_support") {
-		options := new(ec2.ModifyVpcAttribute)
-		options.EnableDnsSupport = d.Get("enable_dns_support").(bool)
-		options.SetEnableDnsSupport = true
+		val := d.Get("enable_dns_hostnames").(bool)
+		modifyOpts.EnableDNSSupport = &ec2.AttributeBooleanValue{
+			Value: &val,
+		}
 
 		log.Printf(
 			"[INFO] Modifying enable_dns_support vpc attribute for %s: %#v",
-			d.Id(), options)
-		if _, err := ec2conn.ModifyVpcAttribute(d.Id(), options); err != nil {
+			d.Id(), modifyOpts)
+		if err := ec2conn.ModifyVPCAttribute(modifyOpts); err != nil {
 			return err
 		}
 
 		d.SetPartial("enable_dns_support")
 	}
 
-	if err := setTags(ec2conn, d); err != nil {
+	if err := setTagsSDK(ec2conn, d); err != nil {
 		return err
 	} else {
 		d.SetPartial("tags")
@@ -203,11 +231,14 @@ func resourceAwsVpcUpdate(d *schema.ResourceData, meta interface{}) error {
 }
 
 func resourceAwsVpcDelete(d *schema.ResourceData, meta interface{}) error {
-	ec2conn := meta.(*AWSClient).ec2conn
-
+	ec2conn := meta.(*AWSClient).awsEC2conn
+	vpcID := d.Id()
+	DeleteVpcOpts := &ec2.DeleteVPCRequest{
+		VPCID: &vpcID,
+	}
 	log.Printf("[INFO] Deleting VPC: %s", d.Id())
-	if _, err := ec2conn.DeleteVpc(d.Id()); err != nil {
-		ec2err, ok := err.(*ec2.Error)
+	if err := ec2conn.DeleteVPC(DeleteVpcOpts); err != nil {
+		ec2err, ok := err.(*aws.APIError)
 		if ok && ec2err.Code == "InvalidVpcID.NotFound" {
 			return nil
 		}
@@ -222,9 +253,12 @@ func resourceAwsVpcDelete(d *schema.ResourceData, meta interface{}) error {
 // a VPC.
 func VPCStateRefreshFunc(conn *ec2.EC2, id string) resource.StateRefreshFunc {
 	return func() (interface{}, string, error) {
-		resp, err := conn.DescribeVpcs([]string{id}, ec2.NewFilter())
+		DescribeVpcOpts := &ec2.DescribeVPCsRequest{
+			VPCIDs: []string{id},
+		}
+		resp, err := conn.DescribeVPCs(DescribeVpcOpts)
 		if err != nil {
-			if ec2err, ok := err.(*ec2.Error); ok && ec2err.Code == "InvalidVpcID.NotFound" {
+			if ec2err, ok := err.(*aws.APIError); ok && ec2err.Code == "InvalidVpcID.NotFound" {
 				resp = nil
 			} else {
 				log.Printf("Error on VPCStateRefresh: %s", err)
@@ -239,37 +273,53 @@ func VPCStateRefreshFunc(conn *ec2.EC2, id string) resource.StateRefreshFunc {
 		}
 
 		vpc := &resp.VPCs[0]
-		return vpc, vpc.State, nil
+		return vpc, *vpc.State, nil
 	}
 }
 
 func resourceAwsVpcSetDefaultNetworkAcl(conn *ec2.EC2, d *schema.ResourceData) error {
-	filter := ec2.NewFilter()
-	filter.Add("default", "true")
-	filter.Add("vpc-id", d.Id())
-	networkAclResp, err := conn.NetworkAcls(nil, filter)
+	filter1 := &ec2.Filter{
+		Name:   aws.String("default"),
+		Values: []string{("true")},
+	}
+	filter2 := &ec2.Filter{
+		Name:   aws.String("vpc-id"),
+		Values: []string{(d.Id())},
+	}
+	DescribeNetworkACLOpts := &ec2.DescribeNetworkACLsRequest{
+		Filters: []ec2.Filter{*filter1, *filter2},
+	}
+	networkAclResp, err := conn.DescribeNetworkACLs(DescribeNetworkACLOpts)
 
 	if err != nil {
 		return err
 	}
-	if v := networkAclResp.NetworkAcls; len(v) > 0 {
-		d.Set("default_network_acl_id", v[0].NetworkAclId)
+	if v := networkAclResp.NetworkACLs; len(v) > 0 {
+		d.Set("default_network_acl_id", v[0].NetworkACLID)
 	}
 
 	return nil
 }
 
 func resourceAwsVpcSetDefaultSecurityGroup(conn *ec2.EC2, d *schema.ResourceData) error {
-	filter := ec2.NewFilter()
-	filter.Add("group-name", "default")
-	filter.Add("vpc-id", d.Id())
-	securityGroupResp, err := conn.SecurityGroups(nil, filter)
+	filter1 := &ec2.Filter{
+		Name:   aws.String("group-name"),
+		Values: []string{("default")},
+	}
+	filter2 := &ec2.Filter{
+		Name:   aws.String("vpc-id"),
+		Values: []string{(d.Id())},
+	}
+	DescribeSgOpts := &ec2.DescribeSecurityGroupsRequest{
+		Filters: []ec2.Filter{*filter1, *filter2},
+	}
+	securityGroupResp, err := conn.DescribeSecurityGroups(DescribeSgOpts)
 
 	if err != nil {
 		return err
 	}
-	if v := securityGroupResp.Groups; len(v) > 0 {
-		d.Set("default_security_group_id", v[0].Id)
+	if v := securityGroupResp.SecurityGroups; len(v) > 0 {
+		d.Set("default_security_group_id", v[0].GroupID)
 	}
 
 	return nil
diff --git a/builtin/providers/aws/resource_aws_vpc_test.go b/builtin/providers/aws/resource_aws_vpc_test.go
index b555e0875..7e324a5d9 100644
--- a/builtin/providers/aws/resource_aws_vpc_test.go
+++ b/builtin/providers/aws/resource_aws_vpc_test.go
@@ -2,11 +2,11 @@ package aws
 
 import (
 	"fmt"
-	"testing"
-
+	"github.com/hashicorp/aws-sdk-go/aws"
+	"github.com/hashicorp/aws-sdk-go/gen/ec2"
 	"github.com/hashicorp/terraform/helper/resource"
 	"github.com/hashicorp/terraform/terraform"
-	"github.com/mitchellh/goamz/ec2"
+	"testing"
 )
 
 func TestAccVpc_basic(t *testing.T) {
@@ -65,7 +65,7 @@ func TestAccVpc_tags(t *testing.T) {
 					testAccCheckVpcCidr(&vpc, "10.1.0.0/16"),
 					resource.TestCheckResourceAttr(
 						"aws_vpc.foo", "cidr_block", "10.1.0.0/16"),
-					testAccCheckTags(&vpc.Tags, "foo", "bar"),
+					testAccCheckTagsSDK(&vpc.Tags, "foo", "bar"),
 				),
 			},
 
@@ -73,8 +73,8 @@ func TestAccVpc_tags(t *testing.T) {
 				Config: testAccVpcConfigTagsUpdate,
 				Check: resource.ComposeTestCheckFunc(
 					testAccCheckVpcExists("aws_vpc.foo", &vpc),
-					testAccCheckTags(&vpc.Tags, "foo", ""),
-					testAccCheckTags(&vpc.Tags, "bar", "baz"),
+					testAccCheckTagsSDK(&vpc.Tags, "foo", ""),
+					testAccCheckTagsSDK(&vpc.Tags, "bar", "baz"),
 				),
 			},
 		},
@@ -111,7 +111,7 @@ func TestAccVpcUpdate(t *testing.T) {
 }
 
 func testAccCheckVpcDestroy(s *terraform.State) error {
-	conn := testAccProvider.Meta().(*AWSClient).ec2conn
+	conn := testAccProvider.Meta().(*AWSClient).awsEC2conn
 
 	for _, rs := range s.RootModule().Resources {
 		if rs.Type != "aws_vpc" {
@@ -119,7 +119,10 @@ func testAccCheckVpcDestroy(s *terraform.State) error {
 		}
 
 		// Try to find the VPC
-		resp, err := conn.DescribeVpcs([]string{rs.Primary.ID}, ec2.NewFilter())
+		DescribeVpcOpts := &ec2.DescribeVPCsRequest{
+			VPCIDs: []string{rs.Primary.ID},
+		}
+		resp, err := conn.DescribeVPCs(DescribeVpcOpts)
 		if err == nil {
 			if len(resp.VPCs) > 0 {
 				return fmt.Errorf("VPCs still exist.")
@@ -129,7 +132,7 @@ func testAccCheckVpcDestroy(s *terraform.State) error {
 		}
 
 		// Verify the error is what we want
-		ec2err, ok := err.(*ec2.Error)
+		ec2err, ok := err.(*aws.APIError)
 		if !ok {
 			return err
 		}
@@ -143,8 +146,9 @@ func testAccCheckVpcDestroy(s *terraform.State) error {
 
 func testAccCheckVpcCidr(vpc *ec2.VPC, expected string) resource.TestCheckFunc {
 	return func(s *terraform.State) error {
-		if vpc.CidrBlock != expected {
-			return fmt.Errorf("Bad cidr: %s", vpc.CidrBlock)
+		CIDRBlock := vpc.CIDRBlock
+		if *CIDRBlock != expected {
+			return fmt.Errorf("Bad cidr: %s", *vpc.CIDRBlock)
 		}
 
 		return nil
@@ -162,8 +166,11 @@ func testAccCheckVpcExists(n string, vpc *ec2.VPC) resource.TestCheckFunc {
 			return fmt.Errorf("No VPC ID is set")
 		}
 
-		conn := testAccProvider.Meta().(*AWSClient).ec2conn
-		resp, err := conn.DescribeVpcs([]string{rs.Primary.ID}, ec2.NewFilter())
+		conn := testAccProvider.Meta().(*AWSClient).awsEC2conn
+		DescribeVpcOpts := &ec2.DescribeVPCsRequest{
+			VPCIDs: []string{rs.Primary.ID},
+		}
+		resp, err := conn.DescribeVPCs(DescribeVpcOpts)
 		if err != nil {
 			return err
 		}