From 49e57a2683d4edf55a70fe857d7da86b844f035b Mon Sep 17 00:00:00 2001 From: huali9 Date: Thu, 21 Nov 2024 10:09:17 +0800 Subject: [PATCH] add aws capi cases skip testing create CapacityReservation case if CreateCapacityReservation failed --- pkg/capi/aws.go | 266 ++++++++++++++++++++++++++++++ pkg/e2e_test.go | 5 + pkg/framework/aws_client.go | 95 ++++++++++- pkg/framework/capi_machinesets.go | 13 ++ pkg/framework/framework.go | 21 +++ pkg/providers/aws.go | 47 +----- 6 files changed, 401 insertions(+), 46 deletions(-) create mode 100644 pkg/capi/aws.go diff --git a/pkg/capi/aws.go b/pkg/capi/aws.go new file mode 100644 index 000000000..50a531263 --- /dev/null +++ b/pkg/capi/aws.go @@ -0,0 +1,266 @@ +package capi + +import ( + "context" + "fmt" + + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" + configv1 "github.com/openshift/api/config/v1" + mapiv1 "github.com/openshift/api/machine/v1beta1" + "github.com/openshift/cluster-api-actuator-pkg/pkg/framework" + "github.com/openshift/cluster-api-actuator-pkg/pkg/framework/gatherer" + capiinfrastructurev1beta2resourcebuilder "github.com/openshift/cluster-api-actuator-pkg/testutils/resourcebuilder/cluster-api/infrastructure/v1beta2" + corev1 "k8s.io/api/core/v1" + awsv1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2" + clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1" + + "sigs.k8s.io/controller-runtime/pkg/client/config" + + "sigs.k8s.io/controller-runtime/pkg/client" + yaml "sigs.k8s.io/yaml" +) + +const ( + awsMachineTemplateName = "aws-machine-template" + infrastructureName = "cluster" + infraAPIVersion = "infrastructure.cluster.x-k8s.io/v1beta1" +) + +var ( + cl client.Client + ctx = context.Background() + platform configv1.PlatformType + clusterName string + oc *gatherer.CLI +) + +var _ = Describe("Cluster API AWS MachineSet", framework.LabelCAPI, framework.LabelDisruptive, Ordered, func() { + var ( + awsMachineTemplate *awsv1.AWSMachineTemplate + machineSetParams framework.CAPIMachineSetParams + machineSet *clusterv1.MachineSet + mapiDefaultProviderSpec *mapiv1.AWSMachineProviderConfig + deleted bool + err error + ) + + BeforeAll(func() { + cfg, err := config.GetConfig() + Expect(err).ToNot(HaveOccurred(), "Failed to GetConfig") + + cl, err = client.New(cfg, client.Options{}) + Expect(err).ToNot(HaveOccurred(), "Failed to create Kubernetes client for test") + + infra := &configv1.Infrastructure{} + infraName := client.ObjectKey{ + Name: infrastructureName, + } + Expect(cl.Get(ctx, infraName, infra)).To(Succeed(), "Failed to get cluster infrastructure object") + Expect(infra.Status.PlatformStatus).ToNot(BeNil(), "expected the infrastructure Status.PlatformStatus to not be nil") + clusterName = infra.Status.InfrastructureName + platform = infra.Status.PlatformStatus.Type + if platform != configv1.AWSPlatformType { + Skip("Skipping AWS E2E tests") + } + oc, _ = framework.NewCLI() + framework.SkipIfNotTechPreviewNoUpgrade(oc, cl) + _, mapiDefaultProviderSpec = getDefaultAWSMAPIProviderSpec(cl) + machineSetParams = framework.NewCAPIMachineSetParams( + "aws-machineset", + clusterName, + mapiDefaultProviderSpec.Placement.AvailabilityZone, + 1, + corev1.ObjectReference{ + Kind: "AWSMachineTemplate", + APIVersion: infraAPIVersion, + Name: awsMachineTemplateName, + }, + ) + framework.CreateCoreCluster(ctx, cl, clusterName, "AWSCluster") + }) + + BeforeEach(func() { + deleted = false + }) + + AfterEach(func() { + if platform != configv1.AWSPlatformType { + // Because AfterEach always runs, even when tests are skipped, we have to + // explicitly skip it here for other platforms. + Skip("Skipping AWS E2E tests") + } + if !deleted { + framework.DeleteCAPIMachineSets(ctx, cl, machineSet) + framework.WaitForCAPIMachineSetsDeleted(ctx, cl, machineSet) + framework.DeleteObjects(ctx, cl, awsMachineTemplate) + } + }) + + //huliu-OCP-51071 - [CAPI] Create machineset with CAPI on aws + It("should be able to run a machine with a default provider spec", func() { + awsMachineTemplate = newAWSMachineTemplate(mapiDefaultProviderSpec) + if err = cl.Create(ctx, awsMachineTemplate); err != nil { + Expect(err).ToNot(HaveOccurred(), "Failed to create awsmachinetemplate") + } + machineSetParams = framework.UpdateCAPIMachineSetName("aws-machineset-51071", machineSetParams) + machineSet, err = framework.CreateCAPIMachineSet(ctx, cl, machineSetParams) + Expect(err).ToNot(HaveOccurred(), "Failed to create CAPI machineset") + framework.WaitForCAPIMachinesRunning(ctx, cl, machineSet.Name) + }) + + //huliu-OCP-75395 - [CAPI] AWS Placement group support. + It("should be able to run a machine with cluster placement group", func() { + awsClient := framework.NewAwsClient(framework.GetCredentialsFromCluster(oc)) + placementGroupName := clusterName + "pgcluster" + placementGroupID, err := awsClient.CreatePlacementGroup(placementGroupName, "cluster") + Expect(err).ToNot(HaveOccurred(), "Failed to create placementgroup") + Expect(placementGroupID).ToNot(Equal(""), "expected the placementGroupID to not be empty string") + defer func() { + framework.DeleteCAPIMachineSets(ctx, cl, machineSet) + framework.WaitForCAPIMachineSetsDeleted(ctx, cl, machineSet) + framework.DeleteObjects(ctx, cl, awsMachineTemplate) + deleted = true + _, err = awsClient.DeletePlacementGroup(placementGroupName) + Expect(err).ToNot(HaveOccurred(), "Failed to delete placementgroup") + }() + + awsMachineTemplate = newAWSMachineTemplate(mapiDefaultProviderSpec) + awsMachineTemplate.Spec.Template.Spec.PlacementGroupName = placementGroupName + if err = cl.Create(ctx, awsMachineTemplate); err != nil { + Expect(err).ToNot(HaveOccurred(), "Failed to create awsmachinetemplate") + } + machineSetParams = framework.UpdateCAPIMachineSetName("aws-machineset-75395", machineSetParams) + machineSet, err = framework.CreateCAPIMachineSet(ctx, cl, machineSetParams) + Expect(err).ToNot(HaveOccurred(), "Failed to create CAPI machineset") + framework.WaitForCAPIMachinesRunning(ctx, cl, machineSet.Name) + }) + + //huliu-OCP-75396 - [CAPI] Creating machines using KMS keys from AWS. + It("should be able to run a machine using KMS keys", func() { + awsMachineTemplate = newAWSMachineTemplate(mapiDefaultProviderSpec) + region := mapiDefaultProviderSpec.Placement.Region + if region != "us-east-1" && region != "us-east-2" { + Skip("Region is " + region + ", skip this test scenario because we only created kms key in us-east-1/us-east-2 region") + } + var key string + switch region { + case "us-east-1": + key = "arn:aws:kms:us-east-1:301721915996:key/c471ec83-cfaf-41a2-9241-d9e99c4da344" + case "us-east-2": + key = "arn:aws:kms:us-east-2:301721915996:key/c228ef83-df2c-4151-84c4-d9f39f39a972" + } + awskmsClient := framework.NewAwsKmsClient(framework.GetCredentialsFromCluster(oc)) + _, err = awskmsClient.DescribeKeyByID(key) + if err != nil { + Skip(fmt.Sprintf("Skip because cannot get the key %v", err)) + } + encryptBool := true + awsMachineTemplate.Spec.Template.Spec.NonRootVolumes = []awsv1.Volume{ + { + DeviceName: "/dev/xvda", + Size: 140, + Type: awsv1.VolumeTypeIO1, + IOPS: 5000, + Encrypted: &encryptBool, + EncryptionKey: key, + }, + } + if err := cl.Create(ctx, awsMachineTemplate); err != nil { + Expect(err).ToNot(HaveOccurred(), "Failed to create awsmachinetemplate") + } + machineSetParams = framework.UpdateCAPIMachineSetName("aws-machineset-75396", machineSetParams) + machineSet, err = framework.CreateCAPIMachineSet(ctx, cl, machineSetParams) + Expect(err).ToNot(HaveOccurred(), "Failed to create CAPI machineset") + framework.WaitForCAPIMachinesRunning(ctx, cl, machineSet.Name) + }) +}) + +func getDefaultAWSMAPIProviderSpec(cl client.Client) (*mapiv1.MachineSet, *mapiv1.AWSMachineProviderConfig) { + machineSetList := &mapiv1.MachineSetList{} + + Eventually(func() error { + return cl.List(ctx, machineSetList, client.InNamespace(framework.MachineAPINamespace)) + }, framework.WaitShort, framework.RetryShort).Should(Succeed(), "it should be able to list the MAPI machinesets") + + Expect(machineSetList.Items).ToNot(HaveLen(0), "expected the MAPI machinesets to be present") + machineSet := &machineSetList.Items[0] + Expect(machineSet.Spec.Template.Spec.ProviderSpec.Value).ToNot(BeNil(), "expected the MAPI machinesets ProviderSpec value to not be nil") + + providerSpec := &mapiv1.AWSMachineProviderConfig{} + Expect(yaml.Unmarshal(machineSet.Spec.Template.Spec.ProviderSpec.Value.Raw, providerSpec)).To(Succeed(), "it should be able to unmarshal the raw yaml into providerSpec") + + return machineSet, providerSpec +} + +func newAWSMachineTemplate(mapiProviderSpec *mapiv1.AWSMachineProviderConfig) *awsv1.AWSMachineTemplate { + By("Creating AWS machine template") + + Expect(mapiProviderSpec).ToNot(BeNil(), "expected the mapi ProviderSpec to not be nil") + Expect(mapiProviderSpec.IAMInstanceProfile).ToNot(BeNil(), "expected the mapi IAMInstanceProfile to not be nil") + Expect(mapiProviderSpec.IAMInstanceProfile.ID).ToNot(BeNil(), "expected the mapi IAMInstanceProfile.ID to not be nil") + Expect(mapiProviderSpec.InstanceType).ToNot(BeEmpty(), "expected the mapi InstanceType to not be empty") + Expect(mapiProviderSpec.Placement.AvailabilityZone).ToNot(BeEmpty(), "expected the mapi Placement.AvailabilityZone to not be empty") + Expect(mapiProviderSpec.AMI.ID).ToNot(BeNil(), "expected the mapi AMI.ID to not be nil") + Expect(mapiProviderSpec.SecurityGroups).ToNot(HaveLen(0), "expected the mapi SecurityGroups to be present") + Expect(mapiProviderSpec.SecurityGroups[0].Filters).ToNot(HaveLen(0), "expected the mapi SecurityGroups[0].Filters to be present") + Expect(mapiProviderSpec.SecurityGroups[0].Filters[0].Values).ToNot(HaveLen(0), "expected the mapi SecurityGroups[0].Filters[0].Values to be present") + + var subnet awsv1.AWSResourceReference + + if len(mapiProviderSpec.Subnet.Filters) == 0 { + subnet = awsv1.AWSResourceReference{ + ID: mapiProviderSpec.Subnet.ID, + } + } else { + subnet = awsv1.AWSResourceReference{ + Filters: []awsv1.Filter{ + { + Name: "tag:Name", + Values: mapiProviderSpec.Subnet.Filters[0].Values, + }, + }, + } + } + + uncompressedUserData := true + ami := awsv1.AMIReference{ + ID: mapiProviderSpec.AMI.ID, + } + ignition := &awsv1.Ignition{ + Version: "3.4", + StorageType: awsv1.IgnitionStorageTypeOptionUnencryptedUserData, + } + additionalSecurityGroups := []awsv1.AWSResourceReference{ + { + Filters: []awsv1.Filter{ + { + Name: "tag:Name", + Values: mapiProviderSpec.SecurityGroups[0].Filters[0].Values, + }, + }, + }, + { + Filters: []awsv1.Filter{ + { + Name: "tag:Name", + Values: mapiProviderSpec.SecurityGroups[1].Filters[0].Values, + }, + }, + }, + } + awsmt := capiinfrastructurev1beta2resourcebuilder. + AWSMachineTemplate(). + WithUncompressedUserData(uncompressedUserData). + WithIAMInstanceProfile(*mapiProviderSpec.IAMInstanceProfile.ID). + WithInstanceType(mapiProviderSpec.InstanceType). + WithAMI(ami). + WithIgnition(ignition). + WithSubnet(&subnet). + WithAdditionalSecurityGroups(additionalSecurityGroups). + WithName(awsMachineTemplateName). + WithNamespace(framework.ClusterAPINamespace). + Build() + + return awsmt +} diff --git a/pkg/e2e_test.go b/pkg/e2e_test.go index b132bd7b3..d391f64dd 100644 --- a/pkg/e2e_test.go +++ b/pkg/e2e_test.go @@ -14,6 +14,7 @@ import ( machinev1 "github.com/openshift/api/machine/v1beta1" "github.com/openshift/cluster-api-actuator-pkg/pkg/framework" caov1alpha1 "github.com/openshift/cluster-autoscaler-operator/pkg/apis" + awsv1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2" azurev1 "sigs.k8s.io/cluster-api-provider-azure/api/v1beta1" clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1" @@ -48,6 +49,10 @@ func init() { if err := azurev1.AddToScheme(scheme.Scheme); err != nil { klog.Fatal(err) } + + if err := awsv1.AddToScheme(scheme.Scheme); err != nil { + klog.Fatal(err) + } } func TestE2E(t *testing.T) { diff --git a/pkg/framework/aws_client.go b/pkg/framework/aws_client.go index 8f239ca65..cc41af881 100644 --- a/pkg/framework/aws_client.go +++ b/pkg/framework/aws_client.go @@ -4,14 +4,56 @@ import ( "fmt" "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/credentials" + "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/ec2" + "github.com/aws/aws-sdk-go/service/kms" "k8s.io/klog" "k8s.io/utils/ptr" ) // AwsClient struct. type AwsClient struct { - Svc *ec2.EC2 + svc *ec2.EC2 +} + +// Init the aws client. +func NewAwsClient(accessKeyID []byte, secureKey []byte, clusterRegion string) *AwsClient { + awsSession := newAwsSession(accessKeyID, secureKey, clusterRegion) + aClient := &AwsClient{ + svc: ec2.New(awsSession), + } + + return aClient +} + +// AwsKmsClient struct. +type AwsKmsClient struct { + kmssvc *kms.KMS +} + +// Init the aws kms client. +func NewAwsKmsClient(accessKeyID []byte, secureKey []byte, clusterRegion string) *AwsKmsClient { + awsSession := newAwsSession(accessKeyID, secureKey, clusterRegion) + kmsClient := &AwsKmsClient{ + kmssvc: kms.New(awsSession), + } + + return kmsClient +} + +// Create aws backend session connection. +func newAwsSession(accessKeyID []byte, secureKey []byte, clusterRegion string) *session.Session { + awsConfig := &aws.Config{ + Region: aws.String(clusterRegion), + Credentials: credentials.NewStaticCredentials( + string(accessKeyID), + string(secureKey), + "", + ), + } + + return session.Must(session.NewSession(awsConfig)) } // CreateCapacityReservation Create CapacityReservation. @@ -24,7 +66,7 @@ func (a *AwsClient) CreateCapacityReservation(instanceType string, instancePlatf InstanceMatchCriteria: aws.String("targeted"), EndDateType: aws.String("unlimited"), } - result, err := a.Svc.CreateCapacityReservation(input) + result, err := a.svc.CreateCapacityReservation(input) if err != nil { return "", fmt.Errorf("error creating capacity reservation: %w", err) @@ -41,7 +83,54 @@ func (a *AwsClient) CancelCapacityReservation(capacityReservationID string) (boo input := &ec2.CancelCapacityReservationInput{ CapacityReservationId: aws.String(capacityReservationID), } - result, err := a.Svc.CancelCapacityReservation(input) + result, err := a.svc.CancelCapacityReservation(input) return ptr.Deref(result.Return, false), err } + +// CreatePlacementGroup Create a PlacementGroup. +func (a *AwsClient) CreatePlacementGroup(groupName string, strategy string, partitionCount ...int64) (string, error) { + var input *ec2.CreatePlacementGroupInput + if len(partitionCount) > 0 { + input = &ec2.CreatePlacementGroupInput{ + GroupName: aws.String(groupName), + PartitionCount: aws.Int64(partitionCount[0]), + Strategy: aws.String(strategy), + } + } else { + input = &ec2.CreatePlacementGroupInput{ + GroupName: aws.String(groupName), + Strategy: aws.String(strategy), + } + } + + result, err := a.svc.CreatePlacementGroup(input) + + if err != nil { + return "", fmt.Errorf("error creating placement group: %w", err) + } + + placementGroupID := ptr.Deref(result.PlacementGroup.GroupId, "") + klog.Infof("The created placementGroupID is %s", placementGroupID) + + return placementGroupID, err +} + +// DeletePlacementGroup Delete a PlacementGroup. +func (a *AwsClient) DeletePlacementGroup(groupName string) (string, error) { + input := &ec2.DeletePlacementGroupInput{ + GroupName: aws.String(groupName), + } + result, err := a.svc.DeletePlacementGroup(input) + + return result.String(), err +} + +// Describes aws customer managed kms key info. +func (akms *AwsKmsClient) DescribeKeyByID(kmsKeyID string) (describeResult *kms.DescribeKeyOutput, err error) { + input := &kms.DescribeKeyInput{ + KeyId: aws.String(kmsKeyID), + } + + return akms.kmssvc.DescribeKey(input) +} diff --git a/pkg/framework/capi_machinesets.go b/pkg/framework/capi_machinesets.go index 87dd5798e..c7866c977 100644 --- a/pkg/framework/capi_machinesets.go +++ b/pkg/framework/capi_machinesets.go @@ -40,6 +40,19 @@ func NewCAPIMachineSetParams(msName, clusterName, failureDomain string, replicas } } +// UpdateCAPIMachineSetName returns CAPIMachineSetParams object with the updated machineset name. +func UpdateCAPIMachineSetName(msName string, params CAPIMachineSetParams) CAPIMachineSetParams { + Expect(msName).ToNot(BeEmpty(), "expected the capi msName to not be empty") + + return CAPIMachineSetParams{ + msName: msName, + clusterName: params.clusterName, + replicas: params.replicas, + infrastructureRef: params.infrastructureRef, + failureDomain: params.failureDomain, + } +} + // CreateCAPIMachineSet creates a new MachineSet resource. func CreateCAPIMachineSet(ctx context.Context, cl client.Client, params CAPIMachineSetParams) (*clusterv1.MachineSet, error) { By(fmt.Sprintf("Creating MachineSet %q", params.msName)) diff --git a/pkg/framework/framework.go b/pkg/framework/framework.go index 9be416c01..f6e40b6ed 100644 --- a/pkg/framework/framework.go +++ b/pkg/framework/framework.go @@ -2,6 +2,7 @@ package framework import ( "context" + "encoding/base64" "errors" "fmt" "os" @@ -12,6 +13,7 @@ import ( . "github.com/onsi/gomega" configv1 "github.com/openshift/api/config/v1" cov1helpers "github.com/openshift/library-go/pkg/config/clusteroperator/v1helpers" + "github.com/tidwall/gjson" admissionregistrationv1 "k8s.io/api/admissionregistration/v1" corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/types" @@ -292,3 +294,22 @@ func SkipIfNotTechPreviewNoUpgrade(oc *gatherer.CLI, cl runtimeclient.Client) { Skip("FeatureSet is not TechPreviewNoUpgradec, skip it!") } } + +// GetCredentialsFromCluster get credentials from cluster. +func GetCredentialsFromCluster(oc *gatherer.CLI) ([]byte, []byte, string) { + awscreds, err := oc.WithoutNamespace().Run("get").Args("secret/aws-creds", "-n", "kube-system", "-o", "json").Output() + if err != nil { + Skip("Unable to get AWS credentials secret, skipping the testing.") + } + + accessKeyIDBase64, secureKeyBase64 := gjson.Get(awscreds, `data.aws_access_key_id`).String(), gjson.Get(awscreds, `data.aws_secret_access_key`).String() + + accessKeyID, err := base64.StdEncoding.DecodeString(accessKeyIDBase64) + Expect(err).NotTo(HaveOccurred(), "Failed to decode accessKeyID") + secureKey, err := base64.StdEncoding.DecodeString(secureKeyBase64) + Expect(err).NotTo(HaveOccurred(), "Failed to decode secureKey") + clusterRegion, err := oc.WithoutNamespace().Run("get").Args("infrastructure", "cluster", "-o=jsonpath={.status.platformStatus.aws.region}").Output() + Expect(err).NotTo(HaveOccurred(), "Failed to get clusterRegion") + + return accessKeyID, secureKey, clusterRegion +} diff --git a/pkg/providers/aws.go b/pkg/providers/aws.go index fd0a50328..0574e7b9a 100644 --- a/pkg/providers/aws.go +++ b/pkg/providers/aws.go @@ -2,16 +2,11 @@ package providers import ( "context" - "encoding/base64" "encoding/json" "fmt" "k8s.io/client-go/kubernetes" - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/credentials" - "github.com/aws/aws-sdk-go/aws/session" - "github.com/aws/aws-sdk-go/service/ec2" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" @@ -22,48 +17,12 @@ import ( "github.com/openshift/cluster-api-actuator-pkg/pkg/framework" "github.com/openshift/cluster-api-actuator-pkg/pkg/framework/gatherer" - "github.com/tidwall/gjson" ) const ( amiIDMetadataEndpoint = "http://169.254.169.254/latest/meta-data/ami-id" ) -// createAWSClient create AWS client. -func createAWSClient(oc *gatherer.CLI) *framework.AwsClient { - awscreds, err := oc.WithoutNamespace().Run("get").Args("secret/aws-creds", "-n", "kube-system", "-o", "json").Output() - if err != nil { - Skip("Unable to get AWS credentials secret, skipping the testing.") - } - - accessKeyIDBase64, secureKeyBase64 := gjson.Get(awscreds, `data.aws_access_key_id`).String(), gjson.Get(awscreds, `data.aws_secret_access_key`).String() - - accessKeyID, err := base64.StdEncoding.DecodeString(accessKeyIDBase64) - Expect(err).NotTo(HaveOccurred()) - secureKey, err := base64.StdEncoding.DecodeString(secureKeyBase64) - Expect(err).NotTo(HaveOccurred()) - clusterRegion, err := oc.WithoutNamespace().Run("get").Args("infrastructure", "cluster", "-o=jsonpath={.status.platformStatus.aws.region}").Output() - Expect(err).NotTo(HaveOccurred()) - - awsConfig := &aws.Config{ - Region: aws.String(clusterRegion), - Credentials: credentials.NewStaticCredentials( - string(accessKeyID), - string(secureKey), - "", - ), - } - - sess, err := session.NewSession(awsConfig) - Expect(err).ToNot(HaveOccurred()) - - aClient := &framework.AwsClient{ - Svc: ec2.New(sess), - } - - return aClient -} - var _ = Describe("MetadataServiceOptions", framework.LabelCloudProviderSpecific, framework.LabelProviderAWS, func() { var client runtimeclient.Client var clientset *kubernetes.Clientset @@ -278,9 +237,11 @@ var _ = Describe("CapacityReservationID", framework.LabelCloudProviderSpecific, By("Access AWS to create CapacityReservation") oc, _ := framework.NewCLI() - awsClient := createAWSClient(oc) + awsClient := framework.NewAwsClient(framework.GetCredentialsFromCluster(oc)) capacityReservationID, err := awsClient.CreateCapacityReservation(awsProviderConfig.InstanceType, "Linux/UNIX", awsProviderConfig.Placement.AvailabilityZone, 1) - Expect(err).ToNot(HaveOccurred()) + if err != nil { + Skip(fmt.Sprintf("Skip because CreateCapacityReservation failed %v", err)) + } Expect(capacityReservationID).ToNot(Equal("")) defer func() {