diff --git a/pkg/api/v1/meta.go b/pkg/api/v1/meta.go
index bb1ae2ff79d..20ca06345ae 100644
--- a/pkg/api/v1/meta.go
+++ b/pkg/api/v1/meta.go
@@ -35,6 +35,8 @@ func (meta *ObjectMeta) GetUID() types.UID                   { return meta.UID }
 func (meta *ObjectMeta) SetUID(uid types.UID)                { meta.UID = uid }
 func (meta *ObjectMeta) GetResourceVersion() string          { return meta.ResourceVersion }
 func (meta *ObjectMeta) SetResourceVersion(version string)   { meta.ResourceVersion = version }
+func (meta *ObjectMeta) GetGeneration() int64                { return meta.Generation }
+func (meta *ObjectMeta) SetGeneration(generation int64)      { meta.Generation = generation }
 func (meta *ObjectMeta) GetSelfLink() string                 { return meta.SelfLink }
 func (meta *ObjectMeta) SetSelfLink(selfLink string)         { meta.SelfLink = selfLink }
 func (meta *ObjectMeta) GetCreationTimestamp() metav1.Time   { return meta.CreationTimestamp }
@@ -45,6 +47,10 @@ func (meta *ObjectMeta) GetDeletionTimestamp() *metav1.Time { return meta.Deleti
 func (meta *ObjectMeta) SetDeletionTimestamp(deletionTimestamp *metav1.Time) {
 	meta.DeletionTimestamp = deletionTimestamp
 }
+func (meta *ObjectMeta) GetDeletionGracePeriodSeconds() *int64 { return meta.DeletionGracePeriodSeconds }
+func (meta *ObjectMeta) SetDeletionGracePeriodSeconds(deletionGracePeriodSeconds *int64) {
+	meta.DeletionGracePeriodSeconds = deletionGracePeriodSeconds
+}
 func (meta *ObjectMeta) GetLabels() map[string]string                 { return meta.Labels }
 func (meta *ObjectMeta) SetLabels(labels map[string]string)           { meta.Labels = labels }
 func (meta *ObjectMeta) GetAnnotations() map[string]string            { return meta.Annotations }
diff --git a/pkg/registry/core/service/BUILD b/pkg/registry/core/service/BUILD
index f41e06bd76b..46a26f6fb9f 100644
--- a/pkg/registry/core/service/BUILD
+++ b/pkg/registry/core/service/BUILD
@@ -65,6 +65,7 @@ go_test(
         "//pkg/registry/core/service/portallocator:go_default_library",
         "//pkg/registry/registrytest:go_default_library",
         "//vendor:k8s.io/apimachinery/pkg/api/errors",
+        "//vendor:k8s.io/apimachinery/pkg/api/meta",
         "//vendor:k8s.io/apimachinery/pkg/apis/meta/v1",
         "//vendor:k8s.io/apimachinery/pkg/runtime",
         "//vendor:k8s.io/apimachinery/pkg/util/intstr",
diff --git a/pkg/registry/core/service/rest_test.go b/pkg/registry/core/service/rest_test.go
index 0103c8a1861..de1c993efc7 100644
--- a/pkg/registry/core/service/rest_test.go
+++ b/pkg/registry/core/service/rest_test.go
@@ -23,6 +23,7 @@ import (
 	"testing"
 
 	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
 	utilnet "k8s.io/apimachinery/pkg/util/net"
@@ -98,7 +99,11 @@ func TestServiceRegistryCreate(t *testing.T) {
 		t.Fatalf("Unexpected error: %v", err)
 	}
 	created_service := created_svc.(*api.Service)
-	if !metav1.HasObjectMetaSystemFieldValues(&created_service.ObjectMeta) {
+	objMeta, err := meta.Accessor(created_service)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !metav1.HasObjectMetaSystemFieldValues(objMeta) {
 		t.Errorf("storage did not populate object meta field values")
 	}
 	if created_service.Name != "foo" {
@@ -218,7 +223,11 @@ func TestServiceRegistryCreateMultiNodePortsService(t *testing.T) {
 			t.Fatalf("Unexpected error: %v", err)
 		}
 		created_service := created_svc.(*api.Service)
-		if !metav1.HasObjectMetaSystemFieldValues(&created_service.ObjectMeta) {
+		objMeta, err := meta.Accessor(created_service)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !metav1.HasObjectMetaSystemFieldValues(objMeta) {
 			t.Errorf("storage did not populate object meta field values")
 		}
 		if created_service.Name != test.name {
diff --git a/staging/src/k8s.io/apimachinery/pkg/api/validation/objectmeta.go b/staging/src/k8s.io/apimachinery/pkg/api/validation/objectmeta.go
index 0074e3c979b..66857a2e39e 100644
--- a/staging/src/k8s.io/apimachinery/pkg/api/validation/objectmeta.go
+++ b/staging/src/k8s.io/apimachinery/pkg/api/validation/objectmeta.go
@@ -21,6 +21,7 @@ import (
 	"strings"
 
 	apiequality "k8s.io/apimachinery/pkg/api/equality"
+	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	v1validation "k8s.io/apimachinery/pkg/apis/meta/v1/validation"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -131,47 +132,60 @@ func ValidateImmutableField(newVal, oldVal interface{}, fldPath *field.Path) fie
 // ValidateObjectMeta validates an object's metadata on creation. It expects that name generation has already
 // been performed.
 // It doesn't return an error for rootscoped resources with namespace, because namespace should already be cleared before.
-func ValidateObjectMeta(meta *metav1.ObjectMeta, requiresNamespace bool, nameFn ValidateNameFunc, fldPath *field.Path) field.ErrorList {
+func ValidateObjectMeta(objMeta *metav1.ObjectMeta, requiresNamespace bool, nameFn ValidateNameFunc, fldPath *field.Path) field.ErrorList {
+	metadata, err := meta.Accessor(objMeta)
+	if err != nil {
+		allErrs := field.ErrorList{}
+		allErrs = append(allErrs, field.Invalid(fldPath, objMeta, err.Error()))
+		return allErrs
+	}
+	return ValidateObjectMetaAccessor(metadata, requiresNamespace, nameFn, fldPath)
+}
+
+// ValidateObjectMeta validates an object's metadata on creation. It expects that name generation has already
+// been performed.
+// It doesn't return an error for rootscoped resources with namespace, because namespace should already be cleared before.
+func ValidateObjectMetaAccessor(meta metav1.Object, requiresNamespace bool, nameFn ValidateNameFunc, fldPath *field.Path) field.ErrorList {
 	allErrs := field.ErrorList{}
 
-	if len(meta.GenerateName) != 0 {
-		for _, msg := range nameFn(meta.GenerateName, true) {
-			allErrs = append(allErrs, field.Invalid(fldPath.Child("generateName"), meta.GenerateName, msg))
+	if len(meta.GetGenerateName()) != 0 {
+		for _, msg := range nameFn(meta.GetGenerateName(), true) {
+			allErrs = append(allErrs, field.Invalid(fldPath.Child("generateName"), meta.GetGenerateName(), msg))
 		}
 	}
 	// If the generated name validates, but the calculated value does not, it's a problem with generation, and we
 	// report it here. This may confuse users, but indicates a programming bug and still must be validated.
 	// If there are multiple fields out of which one is required then add an or as a separator
-	if len(meta.Name) == 0 {
+	if len(meta.GetName()) == 0 {
 		allErrs = append(allErrs, field.Required(fldPath.Child("name"), "name or generateName is required"))
 	} else {
-		for _, msg := range nameFn(meta.Name, false) {
-			allErrs = append(allErrs, field.Invalid(fldPath.Child("name"), meta.Name, msg))
+		for _, msg := range nameFn(meta.GetName(), false) {
+			allErrs = append(allErrs, field.Invalid(fldPath.Child("name"), meta.GetName(), msg))
 		}
 	}
 	if requiresNamespace {
-		if len(meta.Namespace) == 0 {
+		if len(meta.GetNamespace()) == 0 {
 			allErrs = append(allErrs, field.Required(fldPath.Child("namespace"), ""))
 		} else {
-			for _, msg := range ValidateNamespaceName(meta.Namespace, false) {
-				allErrs = append(allErrs, field.Invalid(fldPath.Child("namespace"), meta.Namespace, msg))
+			for _, msg := range ValidateNamespaceName(meta.GetNamespace(), false) {
+				allErrs = append(allErrs, field.Invalid(fldPath.Child("namespace"), meta.GetNamespace(), msg))
 			}
 		}
 	} else {
-		if len(meta.Namespace) != 0 {
+		if len(meta.GetNamespace()) != 0 {
 			allErrs = append(allErrs, field.Forbidden(fldPath.Child("namespace"), "not allowed on this type"))
 		}
 	}
-	if len(meta.ClusterName) != 0 {
-		for _, msg := range ValidateClusterName(meta.ClusterName, false) {
-			allErrs = append(allErrs, field.Invalid(fldPath.Child("clusterName"), meta.ClusterName, msg))
+	if len(meta.GetClusterName()) != 0 {
+		for _, msg := range ValidateClusterName(meta.GetClusterName(), false) {
+			allErrs = append(allErrs, field.Invalid(fldPath.Child("clusterName"), meta.GetClusterName(), msg))
 		}
 	}
-	allErrs = append(allErrs, ValidateNonnegativeField(meta.Generation, fldPath.Child("generation"))...)
-	allErrs = append(allErrs, v1validation.ValidateLabels(meta.Labels, fldPath.Child("labels"))...)
-	allErrs = append(allErrs, ValidateAnnotations(meta.Annotations, fldPath.Child("annotations"))...)
-	allErrs = append(allErrs, ValidateOwnerReferences(meta.OwnerReferences, fldPath.Child("ownerReferences"))...)
-	allErrs = append(allErrs, ValidateFinalizers(meta.Finalizers, fldPath.Child("finalizers"))...)
+	allErrs = append(allErrs, ValidateNonnegativeField(meta.GetGeneration(), fldPath.Child("generation"))...)
+	allErrs = append(allErrs, v1validation.ValidateLabels(meta.GetLabels(), fldPath.Child("labels"))...)
+	allErrs = append(allErrs, ValidateAnnotations(meta.GetAnnotations(), fldPath.Child("annotations"))...)
+	allErrs = append(allErrs, ValidateOwnerReferences(meta.GetOwnerReferences(), fldPath.Child("ownerReferences"))...)
+	allErrs = append(allErrs, ValidateFinalizers(meta.GetFinalizers(), fldPath.Child("finalizers"))...)
 	return allErrs
 }
 
@@ -197,65 +211,81 @@ func ValidateFinalizers(finalizers []string, fldPath *field.Path) field.ErrorLis
 
 // ValidateObjectMetaUpdate validates an object's metadata when updated
 func ValidateObjectMetaUpdate(newMeta, oldMeta *metav1.ObjectMeta, fldPath *field.Path) field.ErrorList {
+	newMetadata, err := meta.Accessor(newMeta)
+	if err != nil {
+		allErrs := field.ErrorList{}
+		allErrs = append(allErrs, field.Invalid(fldPath, newMeta, err.Error()))
+		return allErrs
+	}
+	oldMetadata, err := meta.Accessor(oldMeta)
+	if err != nil {
+		allErrs := field.ErrorList{}
+		allErrs = append(allErrs, field.Invalid(fldPath, oldMeta, err.Error()))
+		return allErrs
+	}
+	return ValidateObjectMetaAccessorUpdate(newMetadata, oldMetadata, fldPath)
+}
+
+func ValidateObjectMetaAccessorUpdate(newMeta, oldMeta metav1.Object, fldPath *field.Path) field.ErrorList {
 	allErrs := field.ErrorList{}
 
-	if !RepairMalformedUpdates && newMeta.UID != oldMeta.UID {
-		allErrs = append(allErrs, field.Invalid(fldPath.Child("uid"), newMeta.UID, "field is immutable"))
+	if !RepairMalformedUpdates && newMeta.GetUID() != oldMeta.GetUID() {
+		allErrs = append(allErrs, field.Invalid(fldPath.Child("uid"), newMeta.GetUID(), "field is immutable"))
 	}
 	// in the event it is left empty, set it, to allow clients more flexibility
 	// TODO: remove the following code that repairs the update request when we retire the clients that modify the immutable fields.
 	// Please do not copy this pattern elsewhere; validation functions should not be modifying the objects they are passed!
 	if RepairMalformedUpdates {
-		if len(newMeta.UID) == 0 {
-			newMeta.UID = oldMeta.UID
+		if len(newMeta.GetUID()) == 0 {
+			newMeta.SetUID(oldMeta.GetUID())
 		}
 		// ignore changes to timestamp
-		if oldMeta.CreationTimestamp.IsZero() {
-			oldMeta.CreationTimestamp = newMeta.CreationTimestamp
+		if oldCreationTime := oldMeta.GetCreationTimestamp(); oldCreationTime.IsZero() {
+			oldMeta.SetCreationTimestamp(newMeta.GetCreationTimestamp())
 		} else {
-			newMeta.CreationTimestamp = oldMeta.CreationTimestamp
+			newMeta.SetCreationTimestamp(oldMeta.GetCreationTimestamp())
 		}
 		// an object can never remove a deletion timestamp or clear/change grace period seconds
-		if !oldMeta.DeletionTimestamp.IsZero() {
-			newMeta.DeletionTimestamp = oldMeta.DeletionTimestamp
+		if !oldMeta.GetDeletionTimestamp().IsZero() {
+			newMeta.SetDeletionTimestamp(oldMeta.GetDeletionTimestamp())
 		}
-		if oldMeta.DeletionGracePeriodSeconds != nil && newMeta.DeletionGracePeriodSeconds == nil {
-			newMeta.DeletionGracePeriodSeconds = oldMeta.DeletionGracePeriodSeconds
+		if oldMeta.GetDeletionGracePeriodSeconds() != nil && newMeta.GetDeletionGracePeriodSeconds() == nil {
+			newMeta.SetDeletionGracePeriodSeconds(oldMeta.GetDeletionGracePeriodSeconds())
 		}
 	}
 
 	// TODO: needs to check if newMeta==nil && oldMeta !=nil after the repair logic is removed.
-	if newMeta.DeletionGracePeriodSeconds != nil && (oldMeta.DeletionGracePeriodSeconds == nil || *newMeta.DeletionGracePeriodSeconds != *oldMeta.DeletionGracePeriodSeconds) {
-		allErrs = append(allErrs, field.Invalid(fldPath.Child("deletionGracePeriodSeconds"), newMeta.DeletionGracePeriodSeconds, "field is immutable; may only be changed via deletion"))
+	if newMeta.GetDeletionGracePeriodSeconds() != nil && (oldMeta.GetDeletionGracePeriodSeconds() == nil || *newMeta.GetDeletionGracePeriodSeconds() != *oldMeta.GetDeletionGracePeriodSeconds()) {
+		allErrs = append(allErrs, field.Invalid(fldPath.Child("deletionGracePeriodSeconds"), newMeta.GetDeletionGracePeriodSeconds(), "field is immutable; may only be changed via deletion"))
 	}
-	if newMeta.DeletionTimestamp != nil && (oldMeta.DeletionTimestamp == nil || !newMeta.DeletionTimestamp.Equal(*oldMeta.DeletionTimestamp)) {
-		allErrs = append(allErrs, field.Invalid(fldPath.Child("deletionTimestamp"), newMeta.DeletionTimestamp, "field is immutable; may only be changed via deletion"))
+	if newMeta.GetDeletionTimestamp() != nil && (oldMeta.GetDeletionTimestamp() == nil || !newMeta.GetDeletionTimestamp().Equal(*oldMeta.GetDeletionTimestamp())) {
+		allErrs = append(allErrs, field.Invalid(fldPath.Child("deletionTimestamp"), newMeta.GetDeletionTimestamp(), "field is immutable; may only be changed via deletion"))
 	}
 
 	// Finalizers cannot be added if the object is already being deleted.
-	if oldMeta.DeletionTimestamp != nil {
-		allErrs = append(allErrs, ValidateNoNewFinalizers(newMeta.Finalizers, oldMeta.Finalizers, fldPath.Child("finalizers"))...)
+	if oldMeta.GetDeletionTimestamp() != nil {
+		allErrs = append(allErrs, ValidateNoNewFinalizers(newMeta.GetFinalizers(), oldMeta.GetFinalizers(), fldPath.Child("finalizers"))...)
 	}
 
 	// Reject updates that don't specify a resource version
-	if len(newMeta.ResourceVersion) == 0 {
-		allErrs = append(allErrs, field.Invalid(fldPath.Child("resourceVersion"), newMeta.ResourceVersion, "must be specified for an update"))
+	if len(newMeta.GetResourceVersion()) == 0 {
+		allErrs = append(allErrs, field.Invalid(fldPath.Child("resourceVersion"), newMeta.GetResourceVersion(), "must be specified for an update"))
 	}
 
 	// Generation shouldn't be decremented
-	if newMeta.Generation < oldMeta.Generation {
-		allErrs = append(allErrs, field.Invalid(fldPath.Child("generation"), newMeta.Generation, "must not be decremented"))
+	if newMeta.GetGeneration() < oldMeta.GetGeneration() {
+		allErrs = append(allErrs, field.Invalid(fldPath.Child("generation"), newMeta.GetGeneration(), "must not be decremented"))
 	}
 
-	allErrs = append(allErrs, ValidateImmutableField(newMeta.Name, oldMeta.Name, fldPath.Child("name"))...)
-	allErrs = append(allErrs, ValidateImmutableField(newMeta.Namespace, oldMeta.Namespace, fldPath.Child("namespace"))...)
-	allErrs = append(allErrs, ValidateImmutableField(newMeta.UID, oldMeta.UID, fldPath.Child("uid"))...)
-	allErrs = append(allErrs, ValidateImmutableField(newMeta.CreationTimestamp, oldMeta.CreationTimestamp, fldPath.Child("creationTimestamp"))...)
-	allErrs = append(allErrs, ValidateImmutableField(newMeta.ClusterName, oldMeta.ClusterName, fldPath.Child("clusterName"))...)
+	allErrs = append(allErrs, ValidateImmutableField(newMeta.GetName(), oldMeta.GetName(), fldPath.Child("name"))...)
+	allErrs = append(allErrs, ValidateImmutableField(newMeta.GetNamespace(), oldMeta.GetNamespace(), fldPath.Child("namespace"))...)
+	allErrs = append(allErrs, ValidateImmutableField(newMeta.GetUID(), oldMeta.GetUID(), fldPath.Child("uid"))...)
+	allErrs = append(allErrs, ValidateImmutableField(newMeta.GetCreationTimestamp(), oldMeta.GetCreationTimestamp(), fldPath.Child("creationTimestamp"))...)
+	allErrs = append(allErrs, ValidateImmutableField(newMeta.GetClusterName(), oldMeta.GetClusterName(), fldPath.Child("clusterName"))...)
 
-	allErrs = append(allErrs, v1validation.ValidateLabels(newMeta.Labels, fldPath.Child("labels"))...)
-	allErrs = append(allErrs, ValidateAnnotations(newMeta.Annotations, fldPath.Child("annotations"))...)
-	allErrs = append(allErrs, ValidateOwnerReferences(newMeta.OwnerReferences, fldPath.Child("ownerReferences"))...)
+	allErrs = append(allErrs, v1validation.ValidateLabels(newMeta.GetLabels(), fldPath.Child("labels"))...)
+	allErrs = append(allErrs, ValidateAnnotations(newMeta.GetAnnotations(), fldPath.Child("annotations"))...)
+	allErrs = append(allErrs, ValidateOwnerReferences(newMeta.GetOwnerReferences(), fldPath.Child("ownerReferences"))...)
 
 	return allErrs
 }
diff --git a/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/helpers.go b/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/helpers.go
index b62dd9ee02c..d845d7b0fff 100644
--- a/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/helpers.go
+++ b/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/helpers.go
@@ -228,7 +228,7 @@ func NewUIDPreconditions(uid string) *Preconditions {
 }
 
 // HasObjectMetaSystemFieldValues returns true if fields that are managed by the system on ObjectMeta have values.
-func HasObjectMetaSystemFieldValues(meta *ObjectMeta) bool {
-	return !meta.CreationTimestamp.Time.IsZero() ||
-		len(meta.UID) != 0
+func HasObjectMetaSystemFieldValues(meta Object) bool {
+	return !meta.GetCreationTimestamp().Time.IsZero() ||
+		len(meta.GetUID()) != 0
 }
diff --git a/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/meta.go b/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/meta.go
index f146363cc8b..392f726ad7c 100644
--- a/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/meta.go
+++ b/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/meta.go
@@ -17,25 +17,10 @@ limitations under the License.
 package v1
 
 import (
-	"k8s.io/apimachinery/pkg/conversion"
-	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/types"
 )
 
-// ObjectMetaFor returns a pointer to a provided object's ObjectMeta.
-// TODO: allow runtime.Unknown to extract this object
-// TODO: Remove this function and use meta.ObjectMetaAccessor() instead.
-func ObjectMetaFor(obj runtime.Object) (*ObjectMeta, error) {
-	v, err := conversion.EnforcePtr(obj)
-	if err != nil {
-		return nil, err
-	}
-	var meta *ObjectMeta
-	err = runtime.FieldPtr(v, "ObjectMeta", &meta)
-	return meta, err
-}
-
 // TODO: move this, Object, List, and Type to a different package
 type ObjectMetaAccessor interface {
 	GetObjectMeta() Object
@@ -56,12 +41,16 @@ type Object interface {
 	SetUID(uid types.UID)
 	GetResourceVersion() string
 	SetResourceVersion(version string)
+	GetGeneration() int64
+	SetGeneration(generation int64)
 	GetSelfLink() string
 	SetSelfLink(selfLink string)
 	GetCreationTimestamp() Time
 	SetCreationTimestamp(timestamp Time)
 	GetDeletionTimestamp() *Time
 	SetDeletionTimestamp(timestamp *Time)
+	GetDeletionGracePeriodSeconds() *int64
+	SetDeletionGracePeriodSeconds(*int64)
 	GetLabels() map[string]string
 	SetLabels(labels map[string]string)
 	GetAnnotations() map[string]string
@@ -132,6 +121,8 @@ func (meta *ObjectMeta) GetUID() types.UID                   { return meta.UID }
 func (meta *ObjectMeta) SetUID(uid types.UID)                { meta.UID = uid }
 func (meta *ObjectMeta) GetResourceVersion() string          { return meta.ResourceVersion }
 func (meta *ObjectMeta) SetResourceVersion(version string)   { meta.ResourceVersion = version }
+func (meta *ObjectMeta) GetGeneration() int64                { return meta.Generation }
+func (meta *ObjectMeta) SetGeneration(generation int64)      { meta.Generation = generation }
 func (meta *ObjectMeta) GetSelfLink() string                 { return meta.SelfLink }
 func (meta *ObjectMeta) SetSelfLink(selfLink string)         { meta.SelfLink = selfLink }
 func (meta *ObjectMeta) GetCreationTimestamp() Time          { return meta.CreationTimestamp }
@@ -142,6 +133,10 @@ func (meta *ObjectMeta) GetDeletionTimestamp() *Time { return meta.DeletionTimes
 func (meta *ObjectMeta) SetDeletionTimestamp(deletionTimestamp *Time) {
 	meta.DeletionTimestamp = deletionTimestamp
 }
+func (meta *ObjectMeta) GetDeletionGracePeriodSeconds() *int64 { return meta.DeletionGracePeriodSeconds }
+func (meta *ObjectMeta) SetDeletionGracePeriodSeconds(deletionGracePeriodSeconds *int64) {
+	meta.DeletionGracePeriodSeconds = deletionGracePeriodSeconds
+}
 func (meta *ObjectMeta) GetLabels() map[string]string                 { return meta.Labels }
 func (meta *ObjectMeta) SetLabels(labels map[string]string)           { meta.Labels = labels }
 func (meta *ObjectMeta) GetAnnotations() map[string]string            { return meta.Annotations }
diff --git a/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/unstructured.go b/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/unstructured.go
index ae20726b6ec..d44fd421591 100644
--- a/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/unstructured.go
+++ b/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/unstructured.go
@@ -126,6 +126,20 @@ func getNestedString(obj map[string]interface{}, fields ...string) string {
 	return ""
 }
 
+func getNestedInt64(obj map[string]interface{}, fields ...string) int64 {
+	if str, ok := getNestedField(obj, fields...).(int64); ok {
+		return str
+	}
+	return 0
+}
+
+func getNestedInt64Pointer(obj map[string]interface{}, fields ...string) *int64 {
+	if str, ok := getNestedField(obj, fields...).(*int64); ok {
+		return str
+	}
+	return nil
+}
+
 func getNestedSlice(obj map[string]interface{}, fields ...string) []string {
 	if m, ok := getNestedField(obj, fields...).([]interface{}); ok {
 		strSlice := make([]string, 0, len(m))
@@ -355,6 +369,14 @@ func (u *Unstructured) SetResourceVersion(version string) {
 	u.setNestedField(version, "metadata", "resourceVersion")
 }
 
+func (u *Unstructured) GetGeneration() int64 {
+	return getNestedInt64(u.Object, "metadata", "generation")
+}
+
+func (u *Unstructured) SetGeneration(generation int64) {
+	u.setNestedField(generation, "metadata", "generation")
+}
+
 func (u *Unstructured) GetSelfLink() string {
 	return getNestedString(u.Object, "metadata", "selfLink")
 }
@@ -388,6 +410,14 @@ func (u *Unstructured) SetDeletionTimestamp(timestamp *metav1.Time) {
 	u.setNestedField(ts, "metadata", "deletionTimestamp")
 }
 
+func (u *Unstructured) GetDeletionGracePeriodSeconds() *int64 {
+	return getNestedInt64Pointer(u.Object, "metadata", "deletionGracePeriodSeconds")
+}
+
+func (u *Unstructured) SetDeletionGracePeriodSeconds(deletionGracePeriodSeconds *int64) {
+	u.setNestedField(deletionGracePeriodSeconds, "metadata", "deletionGracePeriodSeconds")
+}
+
 func (u *Unstructured) GetLabels() map[string]string {
 	return getNestedMap(u.Object, "metadata", "labels")
 }
diff --git a/staging/src/k8s.io/apiserver/pkg/registry/generic/registry/store.go b/staging/src/k8s.io/apiserver/pkg/registry/generic/registry/store.go
index 3f8f8d566e2..8f39a9f294f 100644
--- a/staging/src/k8s.io/apiserver/pkg/registry/generic/registry/store.go
+++ b/staging/src/k8s.io/apiserver/pkg/registry/generic/registry/store.go
@@ -331,17 +331,17 @@ func (e *Store) shouldDeleteDuringUpdate(ctx genericapirequest.Context, key stri
 	if !e.EnableGarbageCollection {
 		return false
 	}
-	newMeta, err := metav1.ObjectMetaFor(obj)
+	newMeta, err := meta.Accessor(obj)
 	if err != nil {
 		utilruntime.HandleError(err)
 		return false
 	}
-	oldMeta, err := metav1.ObjectMetaFor(existing)
+	oldMeta, err := meta.Accessor(existing)
 	if err != nil {
 		utilruntime.HandleError(err)
 		return false
 	}
-	return len(newMeta.Finalizers) == 0 && oldMeta.DeletionGracePeriodSeconds != nil && *oldMeta.DeletionGracePeriodSeconds == 0
+	return len(newMeta.GetFinalizers()) == 0 && oldMeta.GetDeletionGracePeriodSeconds() != nil && *oldMeta.GetDeletionGracePeriodSeconds() == 0
 }
 
 // deleteForEmptyFinalizers handles deleting an object once its finalizer list
@@ -652,7 +652,7 @@ func shouldUpdateFinalizers(e *Store, accessor metav1.Object, options *metav1.De
 // DeletionTimestamp to "now". Finalizers are watching for such updates and will
 // finalize the object if their IDs are present in the object's Finalizers list.
 func markAsDeleting(obj runtime.Object) (err error) {
-	objectMeta, kerr := metav1.ObjectMetaFor(obj)
+	objectMeta, kerr := meta.Accessor(obj)
 	if kerr != nil {
 		return kerr
 	}
@@ -660,12 +660,12 @@ func markAsDeleting(obj runtime.Object) (err error) {
 	// This handles Generation bump for resources that don't support graceful
 	// deletion. For resources that support graceful deletion is handle in
 	// pkg/api/rest/delete.go
-	if objectMeta.DeletionTimestamp == nil && objectMeta.Generation > 0 {
-		objectMeta.Generation++
+	if objectMeta.GetDeletionTimestamp() == nil && objectMeta.GetGeneration() > 0 {
+		objectMeta.SetGeneration(objectMeta.GetGeneration() + 1)
 	}
-	objectMeta.DeletionTimestamp = &now
+	objectMeta.SetDeletionTimestamp(&now)
 	var zero int64 = 0
-	objectMeta.DeletionGracePeriodSeconds = &zero
+	objectMeta.SetDeletionGracePeriodSeconds(&zero)
 	return nil
 }
 
diff --git a/staging/src/k8s.io/apiserver/pkg/registry/rest/create.go b/staging/src/k8s.io/apiserver/pkg/registry/rest/create.go
index 43b5e0ad420..60ac7ccf218 100644
--- a/staging/src/k8s.io/apiserver/pkg/registry/rest/create.go
+++ b/staging/src/k8s.io/apiserver/pkg/registry/rest/create.go
@@ -18,6 +18,7 @@ package rest
 
 import (
 	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/api/meta"
 	genericvalidation "k8s.io/apimachinery/pkg/api/validation"
 	"k8s.io/apimachinery/pkg/api/validation/path"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -71,28 +72,28 @@ func BeforeCreate(strategy RESTCreateStrategy, ctx genericapirequest.Context, ob
 			return errors.NewBadRequest("the namespace of the provided object does not match the namespace sent on the request")
 		}
 	} else {
-		objectMeta.Namespace = metav1.NamespaceNone
+		objectMeta.SetNamespace(metav1.NamespaceNone)
 	}
-	objectMeta.DeletionTimestamp = nil
-	objectMeta.DeletionGracePeriodSeconds = nil
+	objectMeta.SetDeletionTimestamp(nil)
+	objectMeta.SetDeletionGracePeriodSeconds(nil)
 	strategy.PrepareForCreate(ctx, obj)
 	FillObjectMetaSystemFields(ctx, objectMeta)
-	if len(objectMeta.GenerateName) > 0 && len(objectMeta.Name) == 0 {
-		objectMeta.Name = strategy.GenerateName(objectMeta.GenerateName)
+	if len(objectMeta.GetGenerateName()) > 0 && len(objectMeta.GetName()) == 0 {
+		objectMeta.SetName(strategy.GenerateName(objectMeta.GetGenerateName()))
 	}
 
 	// ClusterName is ignored and should not be saved
-	objectMeta.ClusterName = ""
+	objectMeta.SetClusterName("")
 
 	if errs := strategy.Validate(ctx, obj); len(errs) > 0 {
-		return errors.NewInvalid(kind.GroupKind(), objectMeta.Name, errs)
+		return errors.NewInvalid(kind.GroupKind(), objectMeta.GetName(), errs)
 	}
 
 	// Custom validation (including name validation) passed
 	// Now run common validation on object meta
 	// Do this *after* custom validation so that specific error messages are shown whenever possible
-	if errs := genericvalidation.ValidateObjectMeta(objectMeta, strategy.NamespaceScoped(), path.ValidatePathSegmentName, field.NewPath("metadata")); len(errs) > 0 {
-		return errors.NewInvalid(kind.GroupKind(), objectMeta.Name, errs)
+	if errs := genericvalidation.ValidateObjectMetaAccessor(objectMeta, strategy.NamespaceScoped(), path.ValidatePathSegmentName, field.NewPath("metadata")); len(errs) > 0 {
+		return errors.NewInvalid(kind.GroupKind(), objectMeta.GetName(), errs)
 	}
 
 	strategy.Canonicalize(obj)
@@ -112,7 +113,7 @@ func CheckGeneratedNameError(strategy RESTCreateStrategy, err error, obj runtime
 		return kerr
 	}
 
-	if len(objectMeta.GenerateName) == 0 {
+	if len(objectMeta.GetGenerateName()) == 0 {
 		return err
 	}
 
@@ -120,8 +121,8 @@ func CheckGeneratedNameError(strategy RESTCreateStrategy, err error, obj runtime
 }
 
 // objectMetaAndKind retrieves kind and ObjectMeta from a runtime object, or returns an error.
-func objectMetaAndKind(typer runtime.ObjectTyper, obj runtime.Object) (*metav1.ObjectMeta, schema.GroupVersionKind, error) {
-	objectMeta, err := metav1.ObjectMetaFor(obj)
+func objectMetaAndKind(typer runtime.ObjectTyper, obj runtime.Object) (metav1.Object, schema.GroupVersionKind, error) {
+	objectMeta, err := meta.Accessor(obj)
 	if err != nil {
 		return nil, schema.GroupVersionKind{}, errors.NewInternalError(err)
 	}
diff --git a/staging/src/k8s.io/apiserver/pkg/registry/rest/delete.go b/staging/src/k8s.io/apiserver/pkg/registry/rest/delete.go
index ace4bab59be..ad407e3ec8b 100644
--- a/staging/src/k8s.io/apiserver/pkg/registry/rest/delete.go
+++ b/staging/src/k8s.io/apiserver/pkg/registry/rest/delete.go
@@ -71,8 +71,8 @@ func BeforeDelete(strategy RESTDeleteStrategy, ctx genericapirequest.Context, ob
 		return false, false, errors.NewInvalid(schema.GroupKind{}, "", errs)
 	}
 	// Checking the Preconditions here to fail early. They'll be enforced later on when we actually do the deletion, too.
-	if options.Preconditions != nil && options.Preconditions.UID != nil && *options.Preconditions.UID != objectMeta.UID {
-		return false, false, errors.NewConflict(schema.GroupResource{Group: gvk.Group, Resource: gvk.Kind}, objectMeta.Name, fmt.Errorf("the UID in the precondition (%s) does not match the UID in record (%s). The object might have been deleted and then recreated", *options.Preconditions.UID, objectMeta.UID))
+	if options.Preconditions != nil && options.Preconditions.UID != nil && *options.Preconditions.UID != objectMeta.GetUID() {
+		return false, false, errors.NewConflict(schema.GroupResource{Group: gvk.Group, Resource: gvk.Kind}, objectMeta.GetName(), fmt.Errorf("the UID in the precondition (%s) does not match the UID in record (%s). The object might have been deleted and then recreated", *options.Preconditions.UID, objectMeta.GetUID()))
 	}
 	gracefulStrategy, ok := strategy.(RESTGracefulDeleteStrategy)
 	if !ok {
@@ -81,7 +81,7 @@ func BeforeDelete(strategy RESTDeleteStrategy, ctx genericapirequest.Context, ob
 		return false, false, nil
 	}
 	// if the object is already being deleted, no need to update generation.
-	if objectMeta.DeletionTimestamp != nil {
+	if objectMeta.GetDeletionTimestamp() != nil {
 		// if we are already being deleted, we may only shorten the deletion grace period
 		// this means the object was gracefully deleted previously but deletionGracePeriodSeconds was not set,
 		// so we force deletion immediately
@@ -93,24 +93,24 @@ func BeforeDelete(strategy RESTDeleteStrategy, ctx genericapirequest.Context, ob
 		// a resource was previously left in a state that was non-recoverable.  We
 		// check if the existing stored resource has a grace period as 0 and if so
 		// attempt to delete immediately in order to recover from this scenario.
-		if objectMeta.DeletionGracePeriodSeconds == nil || *objectMeta.DeletionGracePeriodSeconds == 0 {
+		if objectMeta.GetDeletionGracePeriodSeconds() == nil || *objectMeta.GetDeletionGracePeriodSeconds() == 0 {
 			return false, false, nil
 		}
 		// only a shorter grace period may be provided by a user
 		if options.GracePeriodSeconds != nil {
 			period := int64(*options.GracePeriodSeconds)
-			if period >= *objectMeta.DeletionGracePeriodSeconds {
+			if period >= *objectMeta.GetDeletionGracePeriodSeconds() {
 				return false, true, nil
 			}
 			newDeletionTimestamp := metav1.NewTime(
-				objectMeta.DeletionTimestamp.Add(-time.Second * time.Duration(*objectMeta.DeletionGracePeriodSeconds)).
+				objectMeta.GetDeletionTimestamp().Add(-time.Second * time.Duration(*objectMeta.GetDeletionGracePeriodSeconds())).
 					Add(time.Second * time.Duration(*options.GracePeriodSeconds)))
-			objectMeta.DeletionTimestamp = &newDeletionTimestamp
-			objectMeta.DeletionGracePeriodSeconds = &period
+			objectMeta.SetDeletionTimestamp(&newDeletionTimestamp)
+			objectMeta.SetDeletionGracePeriodSeconds(&period)
 			return true, false, nil
 		}
 		// graceful deletion is pending, do nothing
-		options.GracePeriodSeconds = objectMeta.DeletionGracePeriodSeconds
+		options.GracePeriodSeconds = objectMeta.GetDeletionGracePeriodSeconds()
 		return false, true, nil
 	}
 
@@ -118,14 +118,14 @@ func BeforeDelete(strategy RESTDeleteStrategy, ctx genericapirequest.Context, ob
 		return false, false, nil
 	}
 	now := metav1.NewTime(metav1.Now().Add(time.Second * time.Duration(*options.GracePeriodSeconds)))
-	objectMeta.DeletionTimestamp = &now
-	objectMeta.DeletionGracePeriodSeconds = options.GracePeriodSeconds
+	objectMeta.SetDeletionTimestamp(&now)
+	objectMeta.SetDeletionGracePeriodSeconds(options.GracePeriodSeconds)
 	// If it's the first graceful deletion we are going to set the DeletionTimestamp to non-nil.
 	// Controllers of the object that's being deleted shouldn't take any nontrivial actions, hence its behavior changes.
 	// Thus we need to bump object's Generation (if set). This handles generation bump during graceful deletion.
 	// The bump for objects that don't support graceful deletion is handled in pkg/registry/generic/registry/store.go.
-	if objectMeta.Generation > 0 {
-		objectMeta.Generation++
+	if objectMeta.GetGeneration() > 0 {
+		objectMeta.SetGeneration(objectMeta.GetGeneration() + 1)
 	}
 	return true, false, nil
 }
diff --git a/staging/src/k8s.io/apiserver/pkg/registry/rest/meta.go b/staging/src/k8s.io/apiserver/pkg/registry/rest/meta.go
index 5a6d079ad8e..7257833ba1c 100644
--- a/staging/src/k8s.io/apiserver/pkg/registry/rest/meta.go
+++ b/staging/src/k8s.io/apiserver/pkg/registry/rest/meta.go
@@ -23,16 +23,16 @@ import (
 )
 
 // FillObjectMetaSystemFields populates fields that are managed by the system on ObjectMeta.
-func FillObjectMetaSystemFields(ctx genericapirequest.Context, meta *metav1.ObjectMeta) {
-	meta.CreationTimestamp = metav1.Now()
+func FillObjectMetaSystemFields(ctx genericapirequest.Context, meta metav1.Object) {
+	meta.SetCreationTimestamp(metav1.Now())
 	// allows admission controllers to assign a UID earlier in the request processing
 	// to support tracking resources pending creation.
 	uid, found := genericapirequest.UIDFrom(ctx)
 	if !found {
 		uid = uuid.NewUUID()
 	}
-	meta.UID = uid
-	meta.SelfLink = ""
+	meta.SetUID(uid)
+	meta.SetSelfLink("")
 }
 
 // ValidNamespace returns false if the namespace on the context differs from
@@ -40,10 +40,10 @@ func FillObjectMetaSystemFields(ctx genericapirequest.Context, meta *metav1.Obje
 // the context.
 //
 // TODO(sttts): move into pkg/genericapiserver/endpoints
-func ValidNamespace(ctx genericapirequest.Context, resource *metav1.ObjectMeta) bool {
+func ValidNamespace(ctx genericapirequest.Context, resource metav1.Object) bool {
 	ns, ok := genericapirequest.NamespaceFrom(ctx)
-	if len(resource.Namespace) == 0 {
-		resource.Namespace = ns
+	if len(resource.GetNamespace()) == 0 {
+		resource.SetNamespace(ns)
 	}
-	return ns == resource.Namespace && ok
+	return ns == resource.GetNamespace() && ok
 }
diff --git a/staging/src/k8s.io/apiserver/pkg/registry/rest/meta_test.go b/staging/src/k8s.io/apiserver/pkg/registry/rest/meta_test.go
index e535347750b..a6710423be1 100644
--- a/staging/src/k8s.io/apiserver/pkg/registry/rest/meta_test.go
+++ b/staging/src/k8s.io/apiserver/pkg/registry/rest/meta_test.go
@@ -19,6 +19,7 @@ package rest
 import (
 	"testing"
 
+	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/uuid"
 	"k8s.io/apiserver/pkg/apis/example"
@@ -49,11 +50,15 @@ func TestFillObjectMetaSystemFields(t *testing.T) {
 func TestHasObjectMetaSystemFieldValues(t *testing.T) {
 	ctx := genericapirequest.NewDefaultContext()
 	resource := metav1.ObjectMeta{}
-	if metav1.HasObjectMetaSystemFieldValues(&resource) {
+	objMeta, err := meta.Accessor(&resource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if metav1.HasObjectMetaSystemFieldValues(objMeta) {
 		t.Errorf("the resource does not have all fields yet populated, but incorrectly reports it does")
 	}
 	FillObjectMetaSystemFields(ctx, &resource)
-	if !metav1.HasObjectMetaSystemFieldValues(&resource) {
+	if !metav1.HasObjectMetaSystemFieldValues(objMeta) {
 		t.Errorf("the resource does have all fields populated, but incorrectly reports it does not")
 	}
 }
diff --git a/staging/src/k8s.io/apiserver/pkg/registry/rest/resttest/resttest.go b/staging/src/k8s.io/apiserver/pkg/registry/rest/resttest/resttest.go
index 3d680e4dc66..be2fb94fe38 100644
--- a/staging/src/k8s.io/apiserver/pkg/registry/rest/resttest/resttest.go
+++ b/staging/src/k8s.io/apiserver/pkg/registry/rest/resttest/resttest.go
@@ -25,6 +25,7 @@ import (
 
 	apiequality "k8s.io/apimachinery/pkg/api/equality"
 	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/api/validation/path"
 	metainternalversion "k8s.io/apimachinery/pkg/apis/meta/internalversion"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -107,24 +108,24 @@ func (t *Tester) TestContext() genericapirequest.Context {
 	return genericapirequest.WithNamespace(genericapirequest.NewContext(), t.TestNamespace())
 }
 
-func (t *Tester) getObjectMetaOrFail(obj runtime.Object) *metav1.ObjectMeta {
-	meta, err := metav1.ObjectMetaFor(obj)
+func (t *Tester) getObjectMetaOrFail(obj runtime.Object) metav1.Object {
+	objMeta, err := meta.Accessor(obj)
 	if err != nil {
 		t.Fatalf("object does not have ObjectMeta: %v\n%#v", err, obj)
 	}
-	return meta
+	return objMeta
 }
 
 func (t *Tester) setObjectMeta(obj runtime.Object, name string) {
 	meta := t.getObjectMetaOrFail(obj)
-	meta.Name = name
+	meta.SetName(name)
 	if t.clusterScope {
-		meta.Namespace = metav1.NamespaceNone
+		meta.SetNamespace(metav1.NamespaceNone)
 	} else {
-		meta.Namespace = genericapirequest.NamespaceValue(t.TestContext())
+		meta.SetNamespace(genericapirequest.NamespaceValue(t.TestContext()))
 	}
-	meta.GenerateName = ""
-	meta.Generation = 1
+	meta.SetGenerateName("")
+	meta.SetGeneration(1)
 }
 
 func copyOrDie(obj runtime.Object, copier runtime.ObjectCopier) runtime.Object {
@@ -228,7 +229,7 @@ func (t *Tester) TestWatch(
 // Creation tests.
 
 func (t *Tester) delete(ctx genericapirequest.Context, obj runtime.Object) error {
-	objectMeta, err := metav1.ObjectMetaFor(obj)
+	objectMeta, err := meta.Accessor(obj)
 	if err != nil {
 		return err
 	}
@@ -236,7 +237,7 @@ func (t *Tester) delete(ctx genericapirequest.Context, obj runtime.Object) error
 	if !ok {
 		return fmt.Errorf("Expected deleting storage, got %v", t.storage)
 	}
-	_, _, err = deleter.Delete(ctx, objectMeta.Name, nil)
+	_, _, err = deleter.Delete(ctx, objectMeta.GetName(), nil)
 	return err
 }
 
@@ -276,7 +277,7 @@ func (t *Tester) testCreateEquals(obj runtime.Object, getFn GetFunc) {
 	// Set resource version which might be unset in created object.
 	createdMeta := t.getObjectMetaOrFail(created)
 	gotMeta := t.getObjectMetaOrFail(got)
-	createdMeta.ResourceVersion = gotMeta.ResourceVersion
+	createdMeta.SetResourceVersion(gotMeta.GetResourceVersion())
 
 	if e, a := created, got; !apiequality.Semantic.DeepEqual(e, a) {
 		t.Errorf("unexpected obj: %#v, expected %#v", e, a)
@@ -287,7 +288,7 @@ func (t *Tester) testCreateDiscardsObjectNamespace(valid runtime.Object) {
 	objectMeta := t.getObjectMetaOrFail(valid)
 
 	// Ignore non-empty namespace in object meta
-	objectMeta.Namespace = "not-default"
+	objectMeta.SetNamespace("not-default")
 
 	// Ideally, we'd get an error back here, but at least verify the namespace wasn't persisted
 	created, err := t.storage.(rest.Creater).Create(t.TestContext(), copyOrDie(valid, t.scheme))
@@ -296,30 +297,30 @@ func (t *Tester) testCreateDiscardsObjectNamespace(valid runtime.Object) {
 	}
 	defer t.delete(t.TestContext(), created)
 	createdObjectMeta := t.getObjectMetaOrFail(created)
-	if createdObjectMeta.Namespace != metav1.NamespaceNone {
-		t.Errorf("Expected empty namespace on created object, got '%v'", createdObjectMeta.Namespace)
+	if createdObjectMeta.GetNamespace() != metav1.NamespaceNone {
+		t.Errorf("Expected empty namespace on created object, got '%v'", createdObjectMeta.GetNamespace())
 	}
 }
 
 func (t *Tester) testCreateGeneratesName(valid runtime.Object) {
 	objectMeta := t.getObjectMetaOrFail(valid)
-	objectMeta.Name = ""
-	objectMeta.GenerateName = "test-"
+	objectMeta.SetName("")
+	objectMeta.SetGenerateName("test-")
 
 	created, err := t.storage.(rest.Creater).Create(t.TestContext(), valid)
 	if err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
 	defer t.delete(t.TestContext(), created)
-	if objectMeta.Name == "test-" || !strings.HasPrefix(objectMeta.Name, "test-") {
+	if objectMeta.GetName() == "test-" || !strings.HasPrefix(objectMeta.GetName(), "test-") {
 		t.Errorf("unexpected name: %#v", valid)
 	}
 }
 
 func (t *Tester) testCreateHasMetadata(valid runtime.Object) {
 	objectMeta := t.getObjectMetaOrFail(valid)
-	objectMeta.Name = t.namer(1)
-	objectMeta.Namespace = t.TestNamespace()
+	objectMeta.SetName(t.namer(1))
+	objectMeta.SetNamespace(t.TestNamespace())
 
 	obj, err := t.storage.(rest.Creater).Create(t.TestContext(), valid)
 	if err != nil {
@@ -345,8 +346,8 @@ func (t *Tester) testCreateIgnoresContextNamespace(valid runtime.Object) {
 	}
 	defer t.delete(ctx, created)
 	createdObjectMeta := t.getObjectMetaOrFail(created)
-	if createdObjectMeta.Namespace != metav1.NamespaceNone {
-		t.Errorf("Expected empty namespace on created object, got '%v'", createdObjectMeta.Namespace)
+	if createdObjectMeta.GetNamespace() != metav1.NamespaceNone {
+		t.Errorf("Expected empty namespace on created object, got '%v'", createdObjectMeta.GetNamespace())
 	}
 }
 
@@ -354,7 +355,7 @@ func (t *Tester) testCreateIgnoresMismatchedNamespace(valid runtime.Object) {
 	objectMeta := t.getObjectMetaOrFail(valid)
 
 	// Ignore non-empty namespace in object meta
-	objectMeta.Namespace = "not-default"
+	objectMeta.SetNamespace("not-default")
 	ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), "not-default2")
 
 	// Ideally, we'd get an error back here, but at least verify the namespace wasn't persisted
@@ -364,8 +365,8 @@ func (t *Tester) testCreateIgnoresMismatchedNamespace(valid runtime.Object) {
 	}
 	defer t.delete(ctx, created)
 	createdObjectMeta := t.getObjectMetaOrFail(created)
-	if createdObjectMeta.Namespace != metav1.NamespaceNone {
-		t.Errorf("Expected empty namespace on created object, got '%v'", createdObjectMeta.Namespace)
+	if createdObjectMeta.GetNamespace() != metav1.NamespaceNone {
+		t.Errorf("Expected empty namespace on created object, got '%v'", createdObjectMeta.GetNamespace())
 	}
 }
 
@@ -373,7 +374,7 @@ func (t *Tester) testCreateValidatesNames(valid runtime.Object) {
 	for _, invalidName := range path.NameMayNotBe {
 		objCopy := copyOrDie(valid, t.scheme)
 		objCopyMeta := t.getObjectMetaOrFail(objCopy)
-		objCopyMeta.Name = invalidName
+		objCopyMeta.SetName(invalidName)
 
 		ctx := t.TestContext()
 		_, err := t.storage.(rest.Creater).Create(ctx, objCopy)
@@ -385,7 +386,7 @@ func (t *Tester) testCreateValidatesNames(valid runtime.Object) {
 	for _, invalidSuffix := range path.NameMayNotContain {
 		objCopy := copyOrDie(valid, t.scheme)
 		objCopyMeta := t.getObjectMetaOrFail(objCopy)
-		objCopyMeta.Name += invalidSuffix
+		objCopyMeta.SetName(objCopyMeta.GetName() + invalidSuffix)
 
 		ctx := t.TestContext()
 		_, err := t.storage.(rest.Creater).Create(ctx, objCopy)
@@ -407,7 +408,7 @@ func (t *Tester) testCreateInvokesValidation(invalid ...runtime.Object) {
 
 func (t *Tester) testCreateRejectsMismatchedNamespace(valid runtime.Object) {
 	objectMeta := t.getObjectMetaOrFail(valid)
-	objectMeta.Namespace = "not-default"
+	objectMeta.SetNamespace("not-default")
 
 	_, err := t.storage.(rest.Creater).Create(t.TestContext(), valid)
 	if err == nil {
@@ -420,8 +421,8 @@ func (t *Tester) testCreateRejectsMismatchedNamespace(valid runtime.Object) {
 func (t *Tester) testCreateResetsUserData(valid runtime.Object) {
 	objectMeta := t.getObjectMetaOrFail(valid)
 	now := metav1.Now()
-	objectMeta.UID = "bad-uid"
-	objectMeta.CreationTimestamp = now
+	objectMeta.SetUID("bad-uid")
+	objectMeta.SetCreationTimestamp(now)
 
 	obj, err := t.storage.(rest.Creater).Create(t.TestContext(), valid)
 	if err != nil {
@@ -431,15 +432,15 @@ func (t *Tester) testCreateResetsUserData(valid runtime.Object) {
 		t.Fatalf("Unexpected object from result: %#v", obj)
 	}
 	defer t.delete(t.TestContext(), obj)
-	if objectMeta.UID == "bad-uid" || objectMeta.CreationTimestamp == now {
+	if objectMeta.GetUID() == "bad-uid" || objectMeta.GetCreationTimestamp() == now {
 		t.Errorf("ObjectMeta did not reset basic fields: %#v", objectMeta)
 	}
 }
 
 func (t *Tester) testCreateIgnoreClusterName(valid runtime.Object) {
 	objectMeta := t.getObjectMetaOrFail(valid)
-	objectMeta.Name = t.namer(3)
-	objectMeta.ClusterName = "clustername-to-ignore"
+	objectMeta.SetName(t.namer(3))
+	objectMeta.SetClusterName("clustername-to-ignore")
 
 	obj, err := t.storage.(rest.Creater).Create(t.TestContext(), copyOrDie(valid, t.scheme))
 	if err != nil {
@@ -447,8 +448,8 @@ func (t *Tester) testCreateIgnoreClusterName(valid runtime.Object) {
 	}
 	defer t.delete(t.TestContext(), obj)
 	createdObjectMeta := t.getObjectMetaOrFail(obj)
-	if len(createdObjectMeta.ClusterName) != 0 {
-		t.Errorf("Expected empty clusterName on created object, got '%v'", createdObjectMeta.ClusterName)
+	if len(createdObjectMeta.GetClusterName()) != 0 {
+		t.Errorf("Expected empty clusterName on created object, got '%v'", createdObjectMeta.GetClusterName())
 	}
 }
 
@@ -470,7 +471,7 @@ func (t *Tester) testUpdateEquals(obj runtime.Object, createFn CreateFunc, getFn
 	}
 	toUpdate = updateFn(toUpdate)
 	toUpdateMeta := t.getObjectMetaOrFail(toUpdate)
-	updated, created, err := t.storage.(rest.Updater).Update(ctx, toUpdateMeta.Name, rest.DefaultUpdatedObjectInfo(toUpdate, t.scheme))
+	updated, created, err := t.storage.(rest.Updater).Update(ctx, toUpdateMeta.GetName(), rest.DefaultUpdatedObjectInfo(toUpdate, t.scheme))
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
@@ -484,7 +485,7 @@ func (t *Tester) testUpdateEquals(obj runtime.Object, createFn CreateFunc, getFn
 	// Set resource version which might be unset in created object.
 	updatedMeta := t.getObjectMetaOrFail(updated)
 	gotMeta := t.getObjectMetaOrFail(got)
-	updatedMeta.ResourceVersion = gotMeta.ResourceVersion
+	updatedMeta.SetResourceVersion(gotMeta.GetResourceVersion())
 
 	if e, a := updated, got; !apiequality.Semantic.DeepEqual(e, a) {
 		t.Errorf("unexpected obj: %#v, expected %#v", e, a)
@@ -508,9 +509,9 @@ func (t *Tester) testUpdateFailsOnVersionTooOld(obj runtime.Object, createFn Cre
 
 	older := copyOrDie(storedFoo, t.scheme)
 	olderMeta := t.getObjectMetaOrFail(older)
-	olderMeta.ResourceVersion = "1"
+	olderMeta.SetResourceVersion("1")
 
-	_, _, err = t.storage.(rest.Updater).Update(t.TestContext(), olderMeta.Name, rest.DefaultUpdatedObjectInfo(older, t.scheme))
+	_, _, err = t.storage.(rest.Updater).Update(t.TestContext(), olderMeta.GetName(), rest.DefaultUpdatedObjectInfo(older, t.scheme))
 	if err == nil {
 		t.Errorf("Expected an error, but we didn't get one")
 	} else if !errors.IsConflict(err) {
@@ -530,7 +531,7 @@ func (t *Tester) testUpdateInvokesValidation(obj runtime.Object, createFn Create
 	for _, update := range invalidUpdateFn {
 		toUpdate := update(copyOrDie(foo, t.scheme))
 		toUpdateMeta := t.getObjectMetaOrFail(toUpdate)
-		got, created, err := t.storage.(rest.Updater).Update(t.TestContext(), toUpdateMeta.Name, rest.DefaultUpdatedObjectInfo(toUpdate, t.scheme))
+		got, created, err := t.storage.(rest.Updater).Update(t.TestContext(), toUpdateMeta.GetName(), rest.DefaultUpdatedObjectInfo(toUpdate, t.scheme))
 		if got != nil || created {
 			t.Errorf("expected nil object and no creation for object: %v", toUpdate)
 		}
@@ -545,13 +546,13 @@ func (t *Tester) testUpdateWithWrongUID(obj runtime.Object, createFn CreateFunc,
 	foo := copyOrDie(obj, t.scheme)
 	t.setObjectMeta(foo, t.namer(5))
 	objectMeta := t.getObjectMetaOrFail(foo)
-	objectMeta.UID = types.UID("UID0000")
+	objectMeta.SetUID(types.UID("UID0000"))
 	if err := createFn(ctx, foo); err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
-	objectMeta.UID = types.UID("UID1111")
+	objectMeta.SetUID(types.UID("UID1111"))
 
-	obj, created, err := t.storage.(rest.Updater).Update(ctx, objectMeta.Name, rest.DefaultUpdatedObjectInfo(foo, t.scheme))
+	obj, created, err := t.storage.(rest.Updater).Update(ctx, objectMeta.GetName(), rest.DefaultUpdatedObjectInfo(foo, t.scheme))
 	if created || obj != nil {
 		t.Errorf("expected nil object and no creation for object: %v", foo)
 	}
@@ -565,7 +566,7 @@ func (t *Tester) testUpdateRetrievesOldObject(obj runtime.Object, createFn Creat
 	foo := copyOrDie(obj, t.scheme)
 	t.setObjectMeta(foo, t.namer(6))
 	objectMeta := t.getObjectMetaOrFail(foo)
-	objectMeta.Annotations = map[string]string{"A": "1"}
+	objectMeta.SetAnnotations(map[string]string{"A": "1"})
 	if err := createFn(ctx, foo); err != nil {
 		t.Errorf("unexpected error: %v", err)
 		return
@@ -579,7 +580,7 @@ func (t *Tester) testUpdateRetrievesOldObject(obj runtime.Object, createFn Creat
 
 	storedFooWithUpdates := copyOrDie(storedFoo, t.scheme)
 	objectMeta = t.getObjectMetaOrFail(storedFooWithUpdates)
-	objectMeta.Annotations = map[string]string{"A": "2"}
+	objectMeta.SetAnnotations(map[string]string{"A": "2"})
 
 	// Make sure a custom transform is called, and sees the expected updatedObject and oldObject
 	// This tests the mechanism used to pass the old and new object to admission
@@ -595,7 +596,7 @@ func (t *Tester) testUpdateRetrievesOldObject(obj runtime.Object, createFn Creat
 		return updatedObject, nil
 	}
 
-	updatedObj, created, err := t.storage.(rest.Updater).Update(ctx, objectMeta.Name, rest.DefaultUpdatedObjectInfo(storedFooWithUpdates, t.scheme, noopTransform))
+	updatedObj, created, err := t.storage.(rest.Updater).Update(ctx, objectMeta.GetName(), rest.DefaultUpdatedObjectInfo(storedFooWithUpdates, t.scheme, noopTransform))
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 		return
@@ -654,9 +655,9 @@ func (t *Tester) testUpdateIgnoreGenerationUpdates(obj runtime.Object, createFn
 
 	older := copyOrDie(storedFoo, t.scheme)
 	olderMeta := t.getObjectMetaOrFail(older)
-	olderMeta.Generation = 2
+	olderMeta.SetGeneration(2)
 
-	_, _, err = t.storage.(rest.Updater).Update(t.TestContext(), olderMeta.Name, rest.DefaultUpdatedObjectInfo(older, t.scheme))
+	_, _, err = t.storage.(rest.Updater).Update(t.TestContext(), olderMeta.GetName(), rest.DefaultUpdatedObjectInfo(older, t.scheme))
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
@@ -665,7 +666,7 @@ func (t *Tester) testUpdateIgnoreGenerationUpdates(obj runtime.Object, createFn
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
-	if exp, got := int64(1), t.getObjectMetaOrFail(updatedFoo).Generation; exp != got {
+	if exp, got := int64(1), t.getObjectMetaOrFail(updatedFoo).GetGeneration(); exp != got {
 		t.Errorf("Unexpected generation update: expected %d, got %d", exp, got)
 	}
 }
@@ -704,8 +705,8 @@ func (t *Tester) testUpdateRejectsMismatchedNamespace(obj runtime.Object, create
 	}
 
 	objectMeta := t.getObjectMetaOrFail(storedFoo)
-	objectMeta.Name = t.namer(1)
-	objectMeta.Namespace = "not-default"
+	objectMeta.SetName(t.namer(1))
+	objectMeta.SetNamespace("not-default")
 
 	obj, updated, err := t.storage.(rest.Updater).Update(t.TestContext(), "foo1", rest.DefaultUpdatedObjectInfo(storedFoo, t.scheme))
 	if obj != nil || updated {
@@ -736,9 +737,9 @@ func (t *Tester) testUpdateIgnoreClusterName(obj runtime.Object, createFn Create
 
 	older := copyOrDie(storedFoo, t.scheme)
 	olderMeta := t.getObjectMetaOrFail(older)
-	olderMeta.ClusterName = "clustername-to-ignore"
+	olderMeta.SetClusterName("clustername-to-ignore")
 
-	_, _, err = t.storage.(rest.Updater).Update(t.TestContext(), olderMeta.Name, rest.DefaultUpdatedObjectInfo(older, t.scheme))
+	_, _, err = t.storage.(rest.Updater).Update(t.TestContext(), olderMeta.GetName(), rest.DefaultUpdatedObjectInfo(older, t.scheme))
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
@@ -747,7 +748,7 @@ func (t *Tester) testUpdateIgnoreClusterName(obj runtime.Object, createFn Create
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
-	if clusterName := t.getObjectMetaOrFail(updatedFoo).ClusterName; len(clusterName) != 0 {
+	if clusterName := t.getObjectMetaOrFail(updatedFoo).GetClusterName(); len(clusterName) != 0 {
 		t.Errorf("Unexpected clusterName update: expected empty, got %v", clusterName)
 	}
 
@@ -765,12 +766,12 @@ func (t *Tester) testDeleteNoGraceful(obj runtime.Object, createFn CreateFunc, g
 		t.Errorf("unexpected error: %v", err)
 	}
 	objectMeta := t.getObjectMetaOrFail(foo)
-	obj, wasDeleted, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.Name, metav1.NewDeleteOptions(10))
+	obj, wasDeleted, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.GetName(), metav1.NewDeleteOptions(10))
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
 	if !wasDeleted {
-		t.Errorf("unexpected, object %s should have been deleted immediately", objectMeta.Name)
+		t.Errorf("unexpected, object %s should have been deleted immediately", objectMeta.GetName())
 	}
 	if !t.returnDeletedObject {
 		if status, ok := obj.(*metav1.Status); !ok {
@@ -789,7 +790,7 @@ func (t *Tester) testDeleteNoGraceful(obj runtime.Object, createFn CreateFunc, g
 func (t *Tester) testDeleteNonExist(obj runtime.Object) {
 	objectMeta := t.getObjectMetaOrFail(obj)
 
-	_, _, err := t.storage.(rest.GracefulDeleter).Delete(t.TestContext(), objectMeta.Name, nil)
+	_, _, err := t.storage.(rest.GracefulDeleter).Delete(t.TestContext(), objectMeta.GetName(), nil)
 	if err == nil || !errors.IsNotFound(err) {
 		t.Errorf("unexpected error: %v", err)
 	}
@@ -804,16 +805,16 @@ func (t *Tester) testDeleteWithUID(obj runtime.Object, createFn CreateFunc, getF
 	foo := copyOrDie(obj, t.scheme)
 	t.setObjectMeta(foo, t.namer(1))
 	objectMeta := t.getObjectMetaOrFail(foo)
-	objectMeta.UID = types.UID("UID0000")
+	objectMeta.SetUID(types.UID("UID0000"))
 	if err := createFn(ctx, foo); err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
-	obj, _, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.Name, metav1.NewPreconditionDeleteOptions("UID1111"))
+	obj, _, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.GetName(), metav1.NewPreconditionDeleteOptions("UID1111"))
 	if err == nil || !errors.IsConflict(err) {
 		t.Errorf("unexpected error: %v", err)
 	}
 
-	obj, _, err = t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.Name, metav1.NewPreconditionDeleteOptions("UID0000"))
+	obj, _, err = t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.GetName(), metav1.NewPreconditionDeleteOptions("UID0000"))
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
@@ -844,27 +845,27 @@ func (t *Tester) testDeleteGracefulHasDefault(obj runtime.Object, createFn Creat
 		t.Errorf("unexpected error: %v", err)
 	}
 	objectMeta := t.getObjectMetaOrFail(foo)
-	generation := objectMeta.Generation
-	_, wasDeleted, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.Name, &metav1.DeleteOptions{})
+	generation := objectMeta.GetGeneration()
+	_, wasDeleted, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.GetName(), &metav1.DeleteOptions{})
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
 	if wasDeleted {
-		t.Errorf("unexpected, object %s should not have been deleted immediately", objectMeta.Name)
+		t.Errorf("unexpected, object %s should not have been deleted immediately", objectMeta.GetName())
 	}
 	if _, err := getFn(ctx, foo); err != nil {
 		t.Fatalf("did not gracefully delete resource: %v", err)
 	}
 
-	object, err := t.storage.(rest.Getter).Get(ctx, objectMeta.Name, &metav1.GetOptions{})
+	object, err := t.storage.(rest.Getter).Get(ctx, objectMeta.GetName(), &metav1.GetOptions{})
 	if err != nil {
 		t.Fatalf("unexpected error, object should exist: %v", err)
 	}
 	objectMeta = t.getObjectMetaOrFail(object)
-	if objectMeta.DeletionTimestamp == nil || objectMeta.DeletionGracePeriodSeconds == nil || *objectMeta.DeletionGracePeriodSeconds != expectedGrace {
+	if objectMeta.GetDeletionTimestamp() == nil || objectMeta.GetDeletionGracePeriodSeconds() == nil || *objectMeta.GetDeletionGracePeriodSeconds() != expectedGrace {
 		t.Errorf("unexpected deleted meta: %#v", objectMeta)
 	}
-	if generation >= objectMeta.Generation {
+	if generation >= objectMeta.GetGeneration() {
 		t.Error("Generation wasn't bumped when deletion timestamp was set")
 	}
 }
@@ -878,27 +879,27 @@ func (t *Tester) testDeleteGracefulWithValue(obj runtime.Object, createFn Create
 		t.Errorf("unexpected error: %v", err)
 	}
 	objectMeta := t.getObjectMetaOrFail(foo)
-	generation := objectMeta.Generation
-	_, wasDeleted, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.Name, metav1.NewDeleteOptions(expectedGrace+2))
+	generation := objectMeta.GetGeneration()
+	_, wasDeleted, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.GetName(), metav1.NewDeleteOptions(expectedGrace+2))
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
 	if wasDeleted {
-		t.Errorf("unexpected, object %s should not have been deleted immediately", objectMeta.Name)
+		t.Errorf("unexpected, object %s should not have been deleted immediately", objectMeta.GetName())
 	}
 	if _, err := getFn(ctx, foo); err != nil {
 		t.Fatalf("did not gracefully delete resource: %v", err)
 	}
 
-	object, err := t.storage.(rest.Getter).Get(ctx, objectMeta.Name, &metav1.GetOptions{})
+	object, err := t.storage.(rest.Getter).Get(ctx, objectMeta.GetName(), &metav1.GetOptions{})
 	if err != nil {
 		t.Errorf("unexpected error, object should exist: %v", err)
 	}
 	objectMeta = t.getObjectMetaOrFail(object)
-	if objectMeta.DeletionTimestamp == nil || objectMeta.DeletionGracePeriodSeconds == nil || *objectMeta.DeletionGracePeriodSeconds != expectedGrace+2 {
+	if objectMeta.GetDeletionTimestamp() == nil || objectMeta.GetDeletionGracePeriodSeconds() == nil || *objectMeta.GetDeletionGracePeriodSeconds() != expectedGrace+2 {
 		t.Errorf("unexpected deleted meta: %#v", objectMeta)
 	}
-	if generation >= objectMeta.Generation {
+	if generation >= objectMeta.GetGeneration() {
 		t.Error("Generation wasn't bumped when deletion timestamp was set")
 	}
 }
@@ -912,35 +913,35 @@ func (t *Tester) testDeleteGracefulExtend(obj runtime.Object, createFn CreateFun
 		t.Errorf("unexpected error: %v", err)
 	}
 	objectMeta := t.getObjectMetaOrFail(foo)
-	generation := objectMeta.Generation
-	_, wasDeleted, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.Name, metav1.NewDeleteOptions(expectedGrace))
+	generation := objectMeta.GetGeneration()
+	_, wasDeleted, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.GetName(), metav1.NewDeleteOptions(expectedGrace))
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
 	if wasDeleted {
-		t.Errorf("unexpected, object %s should not have been deleted immediately", objectMeta.Name)
+		t.Errorf("unexpected, object %s should not have been deleted immediately", objectMeta.GetName())
 	}
 	if _, err := getFn(ctx, foo); err != nil {
 		t.Fatalf("did not gracefully delete resource: %v", err)
 	}
 
 	// second delete duration is ignored
-	_, wasDeleted, err = t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.Name, metav1.NewDeleteOptions(expectedGrace+2))
+	_, wasDeleted, err = t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.GetName(), metav1.NewDeleteOptions(expectedGrace+2))
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
 	if wasDeleted {
-		t.Errorf("unexpected, object %s should not have been deleted immediately", objectMeta.Name)
+		t.Errorf("unexpected, object %s should not have been deleted immediately", objectMeta.GetName())
 	}
-	object, err := t.storage.(rest.Getter).Get(ctx, objectMeta.Name, &metav1.GetOptions{})
+	object, err := t.storage.(rest.Getter).Get(ctx, objectMeta.GetName(), &metav1.GetOptions{})
 	if err != nil {
 		t.Errorf("unexpected error, object should exist: %v", err)
 	}
 	objectMeta = t.getObjectMetaOrFail(object)
-	if objectMeta.DeletionTimestamp == nil || objectMeta.DeletionGracePeriodSeconds == nil || *objectMeta.DeletionGracePeriodSeconds != expectedGrace {
+	if objectMeta.GetDeletionTimestamp() == nil || objectMeta.GetDeletionGracePeriodSeconds() == nil || *objectMeta.GetDeletionGracePeriodSeconds() != expectedGrace {
 		t.Errorf("unexpected deleted meta: %#v", objectMeta)
 	}
-	if generation >= objectMeta.Generation {
+	if generation >= objectMeta.GetGeneration() {
 		t.Error("Generation wasn't bumped when deletion timestamp was set")
 	}
 }
@@ -954,36 +955,36 @@ func (t *Tester) testDeleteGracefulImmediate(obj runtime.Object, createFn Create
 		t.Errorf("unexpected error: %v", err)
 	}
 	objectMeta := t.getObjectMetaOrFail(foo)
-	generation := objectMeta.Generation
-	_, wasDeleted, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.Name, metav1.NewDeleteOptions(expectedGrace))
+	generation := objectMeta.GetGeneration()
+	_, wasDeleted, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.GetName(), metav1.NewDeleteOptions(expectedGrace))
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
 	if wasDeleted {
-		t.Errorf("unexpected, object %s should not have been deleted immediately", objectMeta.Name)
+		t.Errorf("unexpected, object %s should not have been deleted immediately", objectMeta.GetName())
 	}
 	if _, err := getFn(ctx, foo); err != nil {
 		t.Fatalf("did not gracefully delete resource: %v", err)
 	}
 
 	// second delete is immediate, resource is deleted
-	out, wasDeleted, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.Name, metav1.NewDeleteOptions(0))
+	out, wasDeleted, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.GetName(), metav1.NewDeleteOptions(0))
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
 	if wasDeleted != true {
-		t.Errorf("unexpected, object %s should have been deleted immediately", objectMeta.Name)
+		t.Errorf("unexpected, object %s should have been deleted immediately", objectMeta.GetName())
 	}
-	_, err = t.storage.(rest.Getter).Get(ctx, objectMeta.Name, &metav1.GetOptions{})
+	_, err = t.storage.(rest.Getter).Get(ctx, objectMeta.GetName(), &metav1.GetOptions{})
 	if !errors.IsNotFound(err) {
 		t.Errorf("unexpected error, object should be deleted immediately: %v", err)
 	}
 	objectMeta = t.getObjectMetaOrFail(out)
-	// the second delete shouldn't update the object, so the objectMeta.DeletionGracePeriodSeconds should eqaul to the value set in the first delete.
-	if objectMeta.DeletionTimestamp == nil || objectMeta.DeletionGracePeriodSeconds == nil || *objectMeta.DeletionGracePeriodSeconds != 0 {
+	// the second delete shouldn't update the object, so the objectMeta.GetDeletionGracePeriodSeconds() should eqaul to the value set in the first delete.
+	if objectMeta.GetDeletionTimestamp() == nil || objectMeta.GetDeletionGracePeriodSeconds() == nil || *objectMeta.GetDeletionGracePeriodSeconds() != 0 {
 		t.Errorf("unexpected deleted meta: %#v", objectMeta)
 	}
-	if generation >= objectMeta.Generation {
+	if generation >= objectMeta.GetGeneration() {
 		t.Error("Generation wasn't bumped when deletion timestamp was set")
 	}
 }
@@ -997,14 +998,14 @@ func (t *Tester) testDeleteGracefulUsesZeroOnNil(obj runtime.Object, createFn Cr
 		t.Errorf("unexpected error: %v", err)
 	}
 	objectMeta := t.getObjectMetaOrFail(foo)
-	_, wasDeleted, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.Name, nil)
+	_, wasDeleted, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.GetName(), nil)
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
 	if !wasDeleted {
-		t.Errorf("unexpected, object %s should have been deleted immediately", objectMeta.Name)
+		t.Errorf("unexpected, object %s should have been deleted immediately", objectMeta.GetName())
 	}
-	if _, err := t.storage.(rest.Getter).Get(ctx, objectMeta.Name, &metav1.GetOptions{}); !errors.IsNotFound(err) {
+	if _, err := t.storage.(rest.Getter).Get(ctx, objectMeta.GetName(), &metav1.GetOptions{}); !errors.IsNotFound(err) {
 		t.Errorf("unexpected error, object should not exist: %v", err)
 	}
 }
@@ -1023,35 +1024,35 @@ func (t *Tester) testDeleteGracefulShorten(obj runtime.Object, createFn CreateFu
 		bigGrace = 2 * expectedGrace
 	}
 	objectMeta := t.getObjectMetaOrFail(foo)
-	_, wasDeleted, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.Name, metav1.NewDeleteOptions(bigGrace))
+	_, wasDeleted, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.GetName(), metav1.NewDeleteOptions(bigGrace))
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
 	if wasDeleted {
-		t.Errorf("unexpected, object %s should not have been deleted immediately", objectMeta.Name)
+		t.Errorf("unexpected, object %s should not have been deleted immediately", objectMeta.GetName())
 	}
 	object, err := getFn(ctx, foo)
 	if err != nil {
 		t.Fatalf("did not gracefully delete resource: %v", err)
 	}
 	objectMeta = t.getObjectMetaOrFail(object)
-	deletionTimestamp := *objectMeta.DeletionTimestamp
+	deletionTimestamp := *objectMeta.GetDeletionTimestamp()
 
 	// second delete duration is ignored
-	_, wasDeleted, err = t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.Name, metav1.NewDeleteOptions(expectedGrace))
+	_, wasDeleted, err = t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.GetName(), metav1.NewDeleteOptions(expectedGrace))
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
 	if wasDeleted {
-		t.Errorf("unexpected, object %s should not have been deleted immediately", objectMeta.Name)
+		t.Errorf("unexpected, object %s should not have been deleted immediately", objectMeta.GetName())
 	}
-	object, err = t.storage.(rest.Getter).Get(ctx, objectMeta.Name, &metav1.GetOptions{})
+	object, err = t.storage.(rest.Getter).Get(ctx, objectMeta.GetName(), &metav1.GetOptions{})
 	if err != nil {
 		t.Errorf("unexpected error, object should exist: %v", err)
 	}
 	objectMeta = t.getObjectMetaOrFail(object)
-	if objectMeta.DeletionTimestamp == nil || objectMeta.DeletionGracePeriodSeconds == nil ||
-		*objectMeta.DeletionGracePeriodSeconds != expectedGrace || !objectMeta.DeletionTimestamp.Before(deletionTimestamp) {
+	if objectMeta.GetDeletionTimestamp() == nil || objectMeta.GetDeletionGracePeriodSeconds() == nil ||
+		*objectMeta.GetDeletionGracePeriodSeconds() != expectedGrace || !objectMeta.GetDeletionTimestamp().Before(deletionTimestamp) {
 		t.Errorf("unexpected deleted meta: %#v", objectMeta)
 	}
 }
@@ -1066,43 +1067,43 @@ func (t *Tester) testGetDifferentNamespace(obj runtime.Object) {
 	}
 
 	objMeta := t.getObjectMetaOrFail(obj)
-	objMeta.Name = t.namer(5)
+	objMeta.SetName(t.namer(5))
 
 	ctx1 := genericapirequest.WithNamespace(genericapirequest.NewContext(), "bar3")
-	objMeta.Namespace = genericapirequest.NamespaceValue(ctx1)
+	objMeta.SetNamespace(genericapirequest.NamespaceValue(ctx1))
 	_, err := t.storage.(rest.Creater).Create(ctx1, obj)
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
 
 	ctx2 := genericapirequest.WithNamespace(genericapirequest.NewContext(), "bar4")
-	objMeta.Namespace = genericapirequest.NamespaceValue(ctx2)
+	objMeta.SetNamespace(genericapirequest.NamespaceValue(ctx2))
 	_, err = t.storage.(rest.Creater).Create(ctx2, obj)
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
 
-	got1, err := t.storage.(rest.Getter).Get(ctx1, objMeta.Name, &metav1.GetOptions{})
+	got1, err := t.storage.(rest.Getter).Get(ctx1, objMeta.GetName(), &metav1.GetOptions{})
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
 	got1Meta := t.getObjectMetaOrFail(got1)
-	if got1Meta.Name != objMeta.Name {
-		t.Errorf("unexpected name of object: %#v, expected: %s", got1, objMeta.Name)
+	if got1Meta.GetName() != objMeta.GetName() {
+		t.Errorf("unexpected name of object: %#v, expected: %s", got1, objMeta.GetName())
 	}
-	if got1Meta.Namespace != genericapirequest.NamespaceValue(ctx1) {
+	if got1Meta.GetNamespace() != genericapirequest.NamespaceValue(ctx1) {
 		t.Errorf("unexpected namespace of object: %#v, expected: %s", got1, genericapirequest.NamespaceValue(ctx1))
 	}
 
-	got2, err := t.storage.(rest.Getter).Get(ctx2, objMeta.Name, &metav1.GetOptions{})
+	got2, err := t.storage.(rest.Getter).Get(ctx2, objMeta.GetName(), &metav1.GetOptions{})
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
 	got2Meta := t.getObjectMetaOrFail(got2)
-	if got2Meta.Name != objMeta.Name {
-		t.Errorf("unexpected name of object: %#v, expected: %s", got2, objMeta.Name)
+	if got2Meta.GetName() != objMeta.GetName() {
+		t.Errorf("unexpected name of object: %#v, expected: %s", got2, objMeta.GetName())
 	}
-	if got2Meta.Namespace != genericapirequest.NamespaceValue(ctx2) {
+	if got2Meta.GetNamespace() != genericapirequest.NamespaceValue(ctx2) {
 		t.Errorf("unexpected namespace of object: %#v, expected: %s", got2, genericapirequest.NamespaceValue(ctx2))
 	}
 }
@@ -1122,7 +1123,7 @@ func (t *Tester) testGetFound(obj runtime.Object) {
 		t.Errorf("unexpected error: %v", err)
 	}
 	gotMeta := t.getObjectMetaOrFail(got)
-	gotMeta.ResourceVersion = existingMeta.ResourceVersion
+	gotMeta.SetResourceVersion(existingMeta.GetResourceVersion())
 	if e, a := existing, got; !apiequality.Semantic.DeepEqual(e, a) {
 		t.Errorf("unexpected obj: %#v, expected %#v", e, a)
 	}
@@ -1132,8 +1133,8 @@ func (t *Tester) testGetMimatchedNamespace(obj runtime.Object) {
 	ctx1 := genericapirequest.WithNamespace(genericapirequest.NewContext(), "bar1")
 	ctx2 := genericapirequest.WithNamespace(genericapirequest.NewContext(), "bar2")
 	objMeta := t.getObjectMetaOrFail(obj)
-	objMeta.Name = t.namer(4)
-	objMeta.Namespace = genericapirequest.NamespaceValue(ctx1)
+	objMeta.SetName(t.namer(4))
+	objMeta.SetNamespace(genericapirequest.NamespaceValue(ctx1))
 	_, err := t.storage.(rest.Creater).Create(ctx1, obj)
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
@@ -1219,9 +1220,9 @@ func (t *Tester) testListMatchLabels(obj runtime.Object, assignFn AssignFunc) {
 	t.setObjectMeta(foo3, "foo3")
 	foo4 := copyOrDie(obj, t.scheme)
 	foo4Meta := t.getObjectMetaOrFail(foo4)
-	foo4Meta.Name = "foo4"
-	foo4Meta.Namespace = genericapirequest.NamespaceValue(ctx)
-	foo4Meta.Labels = testLabels
+	foo4Meta.SetName("foo4")
+	foo4Meta.SetNamespace(genericapirequest.NamespaceValue(ctx))
+	foo4Meta.SetLabels(testLabels)
 
 	objs := ([]runtime.Object{foo3, foo4})
 
diff --git a/staging/src/k8s.io/apiserver/pkg/registry/rest/update.go b/staging/src/k8s.io/apiserver/pkg/registry/rest/update.go
index f5c48de120a..3f2275cd519 100644
--- a/staging/src/k8s.io/apiserver/pkg/registry/rest/update.go
+++ b/staging/src/k8s.io/apiserver/pkg/registry/rest/update.go
@@ -63,16 +63,16 @@ type RESTUpdateStrategy interface {
 // TODO: add other common fields that require global validation.
 func validateCommonFields(obj, old runtime.Object, strategy RESTUpdateStrategy) (field.ErrorList, error) {
 	allErrs := field.ErrorList{}
-	objectMeta, err := metav1.ObjectMetaFor(obj)
+	objectMeta, err := meta.Accessor(obj)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get new object metadata: %v", err)
 	}
-	oldObjectMeta, err := metav1.ObjectMetaFor(old)
+	oldObjectMeta, err := meta.Accessor(old)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get old object metadata: %v", err)
 	}
-	allErrs = append(allErrs, genericvalidation.ValidateObjectMeta(objectMeta, strategy.NamespaceScoped(), path.ValidatePathSegmentName, field.NewPath("metadata"))...)
-	allErrs = append(allErrs, genericvalidation.ValidateObjectMetaUpdate(objectMeta, oldObjectMeta, field.NewPath("metadata"))...)
+	allErrs = append(allErrs, genericvalidation.ValidateObjectMetaAccessor(objectMeta, strategy.NamespaceScoped(), path.ValidatePathSegmentName, field.NewPath("metadata"))...)
+	allErrs = append(allErrs, genericvalidation.ValidateObjectMetaAccessorUpdate(objectMeta, oldObjectMeta, field.NewPath("metadata"))...)
 
 	return allErrs, nil
 }
@@ -90,19 +90,19 @@ func BeforeUpdate(strategy RESTUpdateStrategy, ctx genericapirequest.Context, ob
 			return errors.NewBadRequest("the namespace of the provided object does not match the namespace sent on the request")
 		}
 	} else {
-		objectMeta.Namespace = metav1.NamespaceNone
+		objectMeta.SetNamespace(metav1.NamespaceNone)
 	}
 	// Ensure requests cannot update generation
-	oldMeta, err := metav1.ObjectMetaFor(old)
+	oldMeta, err := meta.Accessor(old)
 	if err != nil {
 		return err
 	}
-	objectMeta.Generation = oldMeta.Generation
+	objectMeta.SetGeneration(oldMeta.GetGeneration())
 
 	strategy.PrepareForUpdate(ctx, obj, old)
 
 	// ClusterName is ignored and should not be saved
-	objectMeta.ClusterName = ""
+	objectMeta.SetClusterName("")
 
 	// Ensure some common fields, like UID, are validated for all resources.
 	errs, err := validateCommonFields(obj, old, strategy)
@@ -112,7 +112,7 @@ func BeforeUpdate(strategy RESTUpdateStrategy, ctx genericapirequest.Context, ob
 
 	errs = append(errs, strategy.ValidateUpdate(ctx, obj, old)...)
 	if len(errs) > 0 {
-		return errors.NewInvalid(kind.GroupKind(), objectMeta.Name, errs)
+		return errors.NewInvalid(kind.GroupKind(), objectMeta.GetName(), errs)
 	}
 
 	strategy.Canonicalize(obj)
diff --git a/staging/src/k8s.io/apiserver/pkg/storage/etcd/etcd_helper.go b/staging/src/k8s.io/apiserver/pkg/storage/etcd/etcd_helper.go
index e2282ddeacc..71f0602b83e 100644
--- a/staging/src/k8s.io/apiserver/pkg/storage/etcd/etcd_helper.go
+++ b/staging/src/k8s.io/apiserver/pkg/storage/etcd/etcd_helper.go
@@ -28,7 +28,6 @@ import (
 	"golang.org/x/net/context"
 
 	"k8s.io/apimachinery/pkg/api/meta"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/conversion"
 	"k8s.io/apimachinery/pkg/runtime"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
@@ -161,12 +160,12 @@ func checkPreconditions(key string, preconditions *storage.Preconditions, out ru
 	if preconditions == nil {
 		return nil
 	}
-	objMeta, err := metav1.ObjectMetaFor(out)
+	objMeta, err := meta.Accessor(out)
 	if err != nil {
 		return storage.NewInternalErrorf("can't enforce preconditions %v on un-introspectable object %v, got error: %v", *preconditions, out, err)
 	}
-	if preconditions.UID != nil && *preconditions.UID != objMeta.UID {
-		errMsg := fmt.Sprintf("Precondition failed: UID in precondition: %v, UID in object meta: %v", preconditions.UID, objMeta.UID)
+	if preconditions.UID != nil && *preconditions.UID != objMeta.GetUID() {
+		errMsg := fmt.Sprintf("Precondition failed: UID in precondition: %v, UID in object meta: %v", preconditions.UID, objMeta.GetUID())
 		return storage.NewInvalidObjError(key, errMsg)
 	}
 	return nil
diff --git a/staging/src/k8s.io/apiserver/pkg/storage/etcd3/store.go b/staging/src/k8s.io/apiserver/pkg/storage/etcd3/store.go
index 1c9b200170c..c138899e3e6 100644
--- a/staging/src/k8s.io/apiserver/pkg/storage/etcd3/store.go
+++ b/staging/src/k8s.io/apiserver/pkg/storage/etcd3/store.go
@@ -30,7 +30,6 @@ import (
 	"golang.org/x/net/context"
 
 	"k8s.io/apimachinery/pkg/api/meta"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/conversion"
 	"k8s.io/apimachinery/pkg/runtime"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
@@ -559,12 +558,12 @@ func checkPreconditions(key string, preconditions *storage.Preconditions, out ru
 	if preconditions == nil {
 		return nil
 	}
-	objMeta, err := metav1.ObjectMetaFor(out)
+	objMeta, err := meta.Accessor(out)
 	if err != nil {
 		return storage.NewInternalErrorf("can't enforce preconditions %v on un-introspectable object %v, got error: %v", *preconditions, out, err)
 	}
-	if preconditions.UID != nil && *preconditions.UID != objMeta.UID {
-		errMsg := fmt.Sprintf("Precondition failed: UID in precondition: %v, UID in object meta: %v", *preconditions.UID, objMeta.UID)
+	if preconditions.UID != nil && *preconditions.UID != objMeta.GetUID() {
+		errMsg := fmt.Sprintf("Precondition failed: UID in precondition: %v, UID in object meta: %v", *preconditions.UID, objMeta.GetUID())
 		return storage.NewInvalidObjError(key, errMsg)
 	}
 	return nil
diff --git a/staging/src/k8s.io/client-go/pkg/api/v1/meta.go b/staging/src/k8s.io/client-go/pkg/api/v1/meta.go
index bb1ae2ff79d..20ca06345ae 100644
--- a/staging/src/k8s.io/client-go/pkg/api/v1/meta.go
+++ b/staging/src/k8s.io/client-go/pkg/api/v1/meta.go
@@ -35,6 +35,8 @@ func (meta *ObjectMeta) GetUID() types.UID                   { return meta.UID }
 func (meta *ObjectMeta) SetUID(uid types.UID)                { meta.UID = uid }
 func (meta *ObjectMeta) GetResourceVersion() string          { return meta.ResourceVersion }
 func (meta *ObjectMeta) SetResourceVersion(version string)   { meta.ResourceVersion = version }
+func (meta *ObjectMeta) GetGeneration() int64                { return meta.Generation }
+func (meta *ObjectMeta) SetGeneration(generation int64)      { meta.Generation = generation }
 func (meta *ObjectMeta) GetSelfLink() string                 { return meta.SelfLink }
 func (meta *ObjectMeta) SetSelfLink(selfLink string)         { meta.SelfLink = selfLink }
 func (meta *ObjectMeta) GetCreationTimestamp() metav1.Time   { return meta.CreationTimestamp }
@@ -45,6 +47,10 @@ func (meta *ObjectMeta) GetDeletionTimestamp() *metav1.Time { return meta.Deleti
 func (meta *ObjectMeta) SetDeletionTimestamp(deletionTimestamp *metav1.Time) {
 	meta.DeletionTimestamp = deletionTimestamp
 }
+func (meta *ObjectMeta) GetDeletionGracePeriodSeconds() *int64 { return meta.DeletionGracePeriodSeconds }
+func (meta *ObjectMeta) SetDeletionGracePeriodSeconds(deletionGracePeriodSeconds *int64) {
+	meta.DeletionGracePeriodSeconds = deletionGracePeriodSeconds
+}
 func (meta *ObjectMeta) GetLabels() map[string]string                 { return meta.Labels }
 func (meta *ObjectMeta) SetLabels(labels map[string]string)           { meta.Labels = labels }
 func (meta *ObjectMeta) GetAnnotations() map[string]string            { return meta.Annotations }
diff --git a/vendor/BUILD b/vendor/BUILD
index 6c5296a39ee..34f4449f90e 100644
--- a/vendor/BUILD
+++ b/vendor/BUILD
@@ -8414,6 +8414,7 @@ go_library(
     tags = ["automanaged"],
     deps = [
         "//vendor:k8s.io/apimachinery/pkg/api/equality",
+        "//vendor:k8s.io/apimachinery/pkg/api/meta",
         "//vendor:k8s.io/apimachinery/pkg/apis/meta/v1",
         "//vendor:k8s.io/apimachinery/pkg/apis/meta/v1/validation",
         "//vendor:k8s.io/apimachinery/pkg/runtime/schema",
@@ -10424,6 +10425,7 @@ go_test(
     library = ":k8s.io/apiserver/pkg/registry/rest",
     tags = ["automanaged"],
     deps = [
+        "//vendor:k8s.io/apimachinery/pkg/api/meta",
         "//vendor:k8s.io/apimachinery/pkg/apis/meta/v1",
         "//vendor:k8s.io/apimachinery/pkg/util/uuid",
         "//vendor:k8s.io/apiserver/pkg/apis/example",
@@ -10468,6 +10470,7 @@ go_library(
     deps = [
         "//vendor:k8s.io/apimachinery/pkg/api/equality",
         "//vendor:k8s.io/apimachinery/pkg/api/errors",
+        "//vendor:k8s.io/apimachinery/pkg/api/meta",
         "//vendor:k8s.io/apimachinery/pkg/api/validation/path",
         "//vendor:k8s.io/apimachinery/pkg/apis/meta/internalversion",
         "//vendor:k8s.io/apimachinery/pkg/apis/meta/v1",