Anthos Multi-Cloud v1 API - Class AwsClustersClient (2.6.0)

public abstract class AwsClustersClient

Namespace

Assembly

Google.Cloud.GkeMultiCloud.V1.dll

Remarks

Properties

CreateAwsClusterOperationsClient

public virtual OperationsClient CreateAwsClusterOperationsClient { get; }

CreateAwsNodePoolOperationsClient

public virtual OperationsClient CreateAwsNodePoolOperationsClient { get; }

DefaultEndpoint

public static string DefaultEndpoint { get; }

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

DeleteAwsClusterOperationsClient

public virtual OperationsClient DeleteAwsClusterOperationsClient { get; }

DeleteAwsNodePoolOperationsClient

public virtual OperationsClient DeleteAwsNodePoolOperationsClient { get; }

GrpcClient

public virtual AwsClusters.AwsClustersClient GrpcClient { get; }

RollbackAwsNodePoolUpdateOperationsClient

public virtual OperationsClient RollbackAwsNodePoolUpdateOperationsClient { get; }

ServiceMetadata

public static ServiceMetadata ServiceMetadata { get; }

UpdateAwsClusterOperationsClient

public virtual OperationsClient UpdateAwsClusterOperationsClient { get; }

UpdateAwsNodePoolOperationsClient

public virtual OperationsClient UpdateAwsNodePoolOperationsClient { get; }

Methods

Create()

public static AwsClustersClient Create()

CreateAsync(CancellationToken)

public static Task<AwsClustersClient> CreateAsync(CancellationToken cancellationToken = default)

CreateAwsCluster(LocationName, AwsCluster, string, CallSettings)

public virtual Operation<AwsCluster, OperationMetadata> CreateAwsCluster(LocationName parent, AwsCluster awsCluster, string awsClusterId, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
AwsCluster awsCluster = new AwsCluster();
string awsClusterId = "";
// Make the request
Operation<AwsCluster, OperationMetadata> response = awsClustersClient.CreateAwsCluster(parent, awsCluster, awsClusterId);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceCreateAwsCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

CreateAwsCluster(CreateAwsClusterRequest, CallSettings)

public virtual Operation<AwsCluster, OperationMetadata> CreateAwsCluster(CreateAwsClusterRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
CreateAwsClusterRequest request = new CreateAwsClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AwsCluster = new AwsCluster(),
    AwsClusterId = "",
    ValidateOnly = false,
};
// Make the request
Operation<AwsCluster, OperationMetadata> response = awsClustersClient.CreateAwsCluster(request);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceCreateAwsCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

CreateAwsCluster(string, AwsCluster, string, CallSettings)

public virtual Operation<AwsCluster, OperationMetadata> CreateAwsCluster(string parent, AwsCluster awsCluster, string awsClusterId, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
AwsCluster awsCluster = new AwsCluster();
string awsClusterId = "";
// Make the request
Operation<AwsCluster, OperationMetadata> response = awsClustersClient.CreateAwsCluster(parent, awsCluster, awsClusterId);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceCreateAwsCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

CreateAwsClusterAsync(LocationName, AwsCluster, string, CallSettings)

public virtual Task<Operation<AwsCluster, OperationMetadata>> CreateAwsClusterAsync(LocationName parent, AwsCluster awsCluster, string awsClusterId, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
AwsCluster awsCluster = new AwsCluster();
string awsClusterId = "";
// Make the request
Operation<AwsCluster, OperationMetadata> response = await awsClustersClient.CreateAwsClusterAsync(parent, awsCluster, awsClusterId);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

CreateAwsClusterAsync(LocationName, AwsCluster, string, CancellationToken)

public virtual Task<Operation<AwsCluster, OperationMetadata>> CreateAwsClusterAsync(LocationName parent, AwsCluster awsCluster, string awsClusterId, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
AwsCluster awsCluster = new AwsCluster();
string awsClusterId = "";
// Make the request
Operation<AwsCluster, OperationMetadata> response = await awsClustersClient.CreateAwsClusterAsync(parent, awsCluster, awsClusterId);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

CreateAwsClusterAsync(CreateAwsClusterRequest, CallSettings)

public virtual Task<Operation<AwsCluster, OperationMetadata>> CreateAwsClusterAsync(CreateAwsClusterRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
CreateAwsClusterRequest request = new CreateAwsClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AwsCluster = new AwsCluster(),
    AwsClusterId = "",
    ValidateOnly = false,
};
// Make the request
Operation<AwsCluster, OperationMetadata> response = await awsClustersClient.CreateAwsClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

CreateAwsClusterAsync(CreateAwsClusterRequest, CancellationToken)

public virtual Task<Operation<AwsCluster, OperationMetadata>> CreateAwsClusterAsync(CreateAwsClusterRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
CreateAwsClusterRequest request = new CreateAwsClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AwsCluster = new AwsCluster(),
    AwsClusterId = "",
    ValidateOnly = false,
};
// Make the request
Operation<AwsCluster, OperationMetadata> response = await awsClustersClient.CreateAwsClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

CreateAwsClusterAsync(string, AwsCluster, string, CallSettings)

public virtual Task<Operation<AwsCluster, OperationMetadata>> CreateAwsClusterAsync(string parent, AwsCluster awsCluster, string awsClusterId, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
AwsCluster awsCluster = new AwsCluster();
string awsClusterId = "";
// Make the request
Operation<AwsCluster, OperationMetadata> response = await awsClustersClient.CreateAwsClusterAsync(parent, awsCluster, awsClusterId);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

CreateAwsClusterAsync(string, AwsCluster, string, CancellationToken)

public virtual Task<Operation<AwsCluster, OperationMetadata>> CreateAwsClusterAsync(string parent, AwsCluster awsCluster, string awsClusterId, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
AwsCluster awsCluster = new AwsCluster();
string awsClusterId = "";
// Make the request
Operation<AwsCluster, OperationMetadata> response = await awsClustersClient.CreateAwsClusterAsync(parent, awsCluster, awsClusterId);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

CreateAwsNodePool(AwsClusterName, AwsNodePool, string, CallSettings)

public virtual Operation<AwsNodePool, OperationMetadata> CreateAwsNodePool(AwsClusterName parent, AwsNodePool awsNodePool, string awsNodePoolId, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
AwsClusterName parent = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
AwsNodePool awsNodePool = new AwsNodePool();
string awsNodePoolId = "";
// Make the request
Operation<AwsNodePool, OperationMetadata> response = awsClustersClient.CreateAwsNodePool(parent, awsNodePool, awsNodePoolId);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceCreateAwsNodePool(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

CreateAwsNodePool(CreateAwsNodePoolRequest, CallSettings)

public virtual Operation<AwsNodePool, OperationMetadata> CreateAwsNodePool(CreateAwsNodePoolRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
CreateAwsNodePoolRequest request = new CreateAwsNodePoolRequest
{
    ParentAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
    AwsNodePool = new AwsNodePool(),
    AwsNodePoolId = "",
    ValidateOnly = false,
};
// Make the request
Operation<AwsNodePool, OperationMetadata> response = awsClustersClient.CreateAwsNodePool(request);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceCreateAwsNodePool(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

CreateAwsNodePool(string, AwsNodePool, string, CallSettings)

public virtual Operation<AwsNodePool, OperationMetadata> CreateAwsNodePool(string parent, AwsNodePool awsNodePool, string awsNodePoolId, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
AwsNodePool awsNodePool = new AwsNodePool();
string awsNodePoolId = "";
// Make the request
Operation<AwsNodePool, OperationMetadata> response = awsClustersClient.CreateAwsNodePool(parent, awsNodePool, awsNodePoolId);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceCreateAwsNodePool(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

CreateAwsNodePoolAsync(AwsClusterName, AwsNodePool, string, CallSettings)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> CreateAwsNodePoolAsync(AwsClusterName parent, AwsNodePool awsNodePool, string awsNodePoolId, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsClusterName parent = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
AwsNodePool awsNodePool = new AwsNodePool();
string awsNodePoolId = "";
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.CreateAwsNodePoolAsync(parent, awsNodePool, awsNodePoolId);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

CreateAwsNodePoolAsync(AwsClusterName, AwsNodePool, string, CancellationToken)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> CreateAwsNodePoolAsync(AwsClusterName parent, AwsNodePool awsNodePool, string awsNodePoolId, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsClusterName parent = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
AwsNodePool awsNodePool = new AwsNodePool();
string awsNodePoolId = "";
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.CreateAwsNodePoolAsync(parent, awsNodePool, awsNodePoolId);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

CreateAwsNodePoolAsync(CreateAwsNodePoolRequest, CallSettings)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> CreateAwsNodePoolAsync(CreateAwsNodePoolRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
CreateAwsNodePoolRequest request = new CreateAwsNodePoolRequest
{
    ParentAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
    AwsNodePool = new AwsNodePool(),
    AwsNodePoolId = "",
    ValidateOnly = false,
};
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.CreateAwsNodePoolAsync(request);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

CreateAwsNodePoolAsync(CreateAwsNodePoolRequest, CancellationToken)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> CreateAwsNodePoolAsync(CreateAwsNodePoolRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
CreateAwsNodePoolRequest request = new CreateAwsNodePoolRequest
{
    ParentAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
    AwsNodePool = new AwsNodePool(),
    AwsNodePoolId = "",
    ValidateOnly = false,
};
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.CreateAwsNodePoolAsync(request);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

CreateAwsNodePoolAsync(string, AwsNodePool, string, CallSettings)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> CreateAwsNodePoolAsync(string parent, AwsNodePool awsNodePool, string awsNodePoolId, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
AwsNodePool awsNodePool = new AwsNodePool();
string awsNodePoolId = "";
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.CreateAwsNodePoolAsync(parent, awsNodePool, awsNodePoolId);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

CreateAwsNodePoolAsync(string, AwsNodePool, string, CancellationToken)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> CreateAwsNodePoolAsync(string parent, AwsNodePool awsNodePool, string awsNodePoolId, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
AwsNodePool awsNodePool = new AwsNodePool();
string awsNodePoolId = "";
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.CreateAwsNodePoolAsync(parent, awsNodePool, awsNodePoolId);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

DeleteAwsCluster(AwsClusterName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteAwsCluster(AwsClusterName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
AwsClusterName name = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
// Make the request
Operation<Empty, OperationMetadata> response = awsClustersClient.DeleteAwsCluster(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceDeleteAwsCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsCluster(DeleteAwsClusterRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteAwsCluster(DeleteAwsClusterRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
DeleteAwsClusterRequest request = new DeleteAwsClusterRequest
{
    AwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
    ValidateOnly = false,
    AllowMissing = false,
    Etag = "",
    IgnoreErrors = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = awsClustersClient.DeleteAwsCluster(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceDeleteAwsCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsCluster(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteAwsCluster(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
// Make the request
Operation<Empty, OperationMetadata> response = awsClustersClient.DeleteAwsCluster(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceDeleteAwsCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsClusterAsync(AwsClusterName, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsClusterAsync(AwsClusterName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsClusterName name = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsClusterAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsClusterAsync(AwsClusterName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsClusterAsync(AwsClusterName name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsClusterName name = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsClusterAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsClusterAsync(DeleteAwsClusterRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsClusterAsync(DeleteAwsClusterRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
DeleteAwsClusterRequest request = new DeleteAwsClusterRequest
{
    AwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
    ValidateOnly = false,
    AllowMissing = false,
    Etag = "",
    IgnoreErrors = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsClusterAsync(DeleteAwsClusterRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsClusterAsync(DeleteAwsClusterRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
DeleteAwsClusterRequest request = new DeleteAwsClusterRequest
{
    AwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
    ValidateOnly = false,
    AllowMissing = false,
    Etag = "",
    IgnoreErrors = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsClusterAsync(string, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsClusterAsync(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsClusterAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsClusterAsync(string, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsClusterAsync(string name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsClusterAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsNodePool(AwsNodePoolName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteAwsNodePool(AwsNodePoolName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
AwsNodePoolName name = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]");
// Make the request
Operation<Empty, OperationMetadata> response = awsClustersClient.DeleteAwsNodePool(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceDeleteAwsNodePool(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsNodePool(DeleteAwsNodePoolRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteAwsNodePool(DeleteAwsNodePoolRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
DeleteAwsNodePoolRequest request = new DeleteAwsNodePoolRequest
{
    AwsNodePoolName = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]"),
    ValidateOnly = false,
    AllowMissing = false,
    Etag = "",
    IgnoreErrors = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = awsClustersClient.DeleteAwsNodePool(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceDeleteAwsNodePool(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsNodePool(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteAwsNodePool(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]/awsNodePools/[AWS_NODE_POOL]";
// Make the request
Operation<Empty, OperationMetadata> response = awsClustersClient.DeleteAwsNodePool(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceDeleteAwsNodePool(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsNodePoolAsync(AwsNodePoolName, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsNodePoolAsync(AwsNodePoolName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsNodePoolName name = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]");
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsNodePoolAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsNodePoolAsync(AwsNodePoolName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsNodePoolAsync(AwsNodePoolName name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsNodePoolName name = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]");
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsNodePoolAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsNodePoolAsync(DeleteAwsNodePoolRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsNodePoolAsync(DeleteAwsNodePoolRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
DeleteAwsNodePoolRequest request = new DeleteAwsNodePoolRequest
{
    AwsNodePoolName = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]"),
    ValidateOnly = false,
    AllowMissing = false,
    Etag = "",
    IgnoreErrors = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsNodePoolAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsNodePoolAsync(DeleteAwsNodePoolRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsNodePoolAsync(DeleteAwsNodePoolRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
DeleteAwsNodePoolRequest request = new DeleteAwsNodePoolRequest
{
    AwsNodePoolName = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]"),
    ValidateOnly = false,
    AllowMissing = false,
    Etag = "",
    IgnoreErrors = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsNodePoolAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsNodePoolAsync(string, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsNodePoolAsync(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]/awsNodePools/[AWS_NODE_POOL]";
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsNodePoolAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsNodePoolAsync(string, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsNodePoolAsync(string name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]/awsNodePools/[AWS_NODE_POOL]";
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsNodePoolAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

GenerateAwsAccessToken(GenerateAwsAccessTokenRequest, CallSettings)

public virtual GenerateAwsAccessTokenResponse GenerateAwsAccessToken(GenerateAwsAccessTokenRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
GenerateAwsAccessTokenRequest request = new GenerateAwsAccessTokenRequest
{
    AwsClusterAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
GenerateAwsAccessTokenResponse response = awsClustersClient.GenerateAwsAccessToken(request);

GenerateAwsAccessTokenAsync(GenerateAwsAccessTokenRequest, CallSettings)

public virtual Task<GenerateAwsAccessTokenResponse> GenerateAwsAccessTokenAsync(GenerateAwsAccessTokenRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GenerateAwsAccessTokenRequest request = new GenerateAwsAccessTokenRequest
{
    AwsClusterAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
GenerateAwsAccessTokenResponse response = await awsClustersClient.GenerateAwsAccessTokenAsync(request);

GenerateAwsAccessTokenAsync(GenerateAwsAccessTokenRequest, CancellationToken)

public virtual Task<GenerateAwsAccessTokenResponse> GenerateAwsAccessTokenAsync(GenerateAwsAccessTokenRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GenerateAwsAccessTokenRequest request = new GenerateAwsAccessTokenRequest
{
    AwsClusterAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
GenerateAwsAccessTokenResponse response = await awsClustersClient.GenerateAwsAccessTokenAsync(request);

GenerateAwsClusterAgentToken(GenerateAwsClusterAgentTokenRequest, CallSettings)

public virtual GenerateAwsClusterAgentTokenResponse GenerateAwsClusterAgentToken(GenerateAwsClusterAgentTokenRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
GenerateAwsClusterAgentTokenRequest request = new GenerateAwsClusterAgentTokenRequest
{
    AwsClusterAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
    SubjectToken = "",
    SubjectTokenType = "",
    Version = "",
    NodePoolId = "",
    GrantType = "",
    Audience = "",
    Scope = "",
    RequestedTokenType = "",
    Options = "",
};
// Make the request
GenerateAwsClusterAgentTokenResponse response = awsClustersClient.GenerateAwsClusterAgentToken(request);

GenerateAwsClusterAgentTokenAsync(GenerateAwsClusterAgentTokenRequest, CallSettings)

public virtual Task<GenerateAwsClusterAgentTokenResponse> GenerateAwsClusterAgentTokenAsync(GenerateAwsClusterAgentTokenRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GenerateAwsClusterAgentTokenRequest request = new GenerateAwsClusterAgentTokenRequest
{
    AwsClusterAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
    SubjectToken = "",
    SubjectTokenType = "",
    Version = "",
    NodePoolId = "",
    GrantType = "",
    Audience = "",
    Scope = "",
    RequestedTokenType = "",
    Options = "",
};
// Make the request
GenerateAwsClusterAgentTokenResponse response = await awsClustersClient.GenerateAwsClusterAgentTokenAsync(request);

GenerateAwsClusterAgentTokenAsync(GenerateAwsClusterAgentTokenRequest, CancellationToken)

public virtual Task<GenerateAwsClusterAgentTokenResponse> GenerateAwsClusterAgentTokenAsync(GenerateAwsClusterAgentTokenRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GenerateAwsClusterAgentTokenRequest request = new GenerateAwsClusterAgentTokenRequest
{
    AwsClusterAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
    SubjectToken = "",
    SubjectTokenType = "",
    Version = "",
    NodePoolId = "",
    GrantType = "",
    Audience = "",
    Scope = "",
    RequestedTokenType = "",
    Options = "",
};
// Make the request
GenerateAwsClusterAgentTokenResponse response = await awsClustersClient.GenerateAwsClusterAgentTokenAsync(request);

GetAwsCluster(AwsClusterName, CallSettings)

public virtual AwsCluster GetAwsCluster(AwsClusterName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
AwsClusterName name = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
// Make the request
AwsCluster response = awsClustersClient.GetAwsCluster(name);

GetAwsCluster(GetAwsClusterRequest, CallSettings)

public virtual AwsCluster GetAwsCluster(GetAwsClusterRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
GetAwsClusterRequest request = new GetAwsClusterRequest
{
    AwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
AwsCluster response = awsClustersClient.GetAwsCluster(request);

GetAwsCluster(string, CallSettings)

public virtual AwsCluster GetAwsCluster(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
// Make the request
AwsCluster response = awsClustersClient.GetAwsCluster(name);

GetAwsClusterAsync(AwsClusterName, CallSettings)

public virtual Task<AwsCluster> GetAwsClusterAsync(AwsClusterName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsClusterName name = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
// Make the request
AwsCluster response = await awsClustersClient.GetAwsClusterAsync(name);

GetAwsClusterAsync(AwsClusterName, CancellationToken)

public virtual Task<AwsCluster> GetAwsClusterAsync(AwsClusterName name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsClusterName name = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
// Make the request
AwsCluster response = await awsClustersClient.GetAwsClusterAsync(name);

GetAwsClusterAsync(GetAwsClusterRequest, CallSettings)

public virtual Task<AwsCluster> GetAwsClusterAsync(GetAwsClusterRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GetAwsClusterRequest request = new GetAwsClusterRequest
{
    AwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
AwsCluster response = await awsClustersClient.GetAwsClusterAsync(request);

GetAwsClusterAsync(GetAwsClusterRequest, CancellationToken)

public virtual Task<AwsCluster> GetAwsClusterAsync(GetAwsClusterRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GetAwsClusterRequest request = new GetAwsClusterRequest
{
    AwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
AwsCluster response = await awsClustersClient.GetAwsClusterAsync(request);

GetAwsClusterAsync(string, CallSettings)

public virtual Task<AwsCluster> GetAwsClusterAsync(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
// Make the request
AwsCluster response = await awsClustersClient.GetAwsClusterAsync(name);

GetAwsClusterAsync(string, CancellationToken)

public virtual Task<AwsCluster> GetAwsClusterAsync(string name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
// Make the request
AwsCluster response = await awsClustersClient.GetAwsClusterAsync(name);

GetAwsJsonWebKeys(GetAwsJsonWebKeysRequest, CallSettings)

public virtual AwsJsonWebKeys GetAwsJsonWebKeys(GetAwsJsonWebKeysRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
GetAwsJsonWebKeysRequest request = new GetAwsJsonWebKeysRequest
{
    AwsClusterAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
AwsJsonWebKeys response = awsClustersClient.GetAwsJsonWebKeys(request);

GetAwsJsonWebKeysAsync(GetAwsJsonWebKeysRequest, CallSettings)

public virtual Task<AwsJsonWebKeys> GetAwsJsonWebKeysAsync(GetAwsJsonWebKeysRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GetAwsJsonWebKeysRequest request = new GetAwsJsonWebKeysRequest
{
    AwsClusterAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
AwsJsonWebKeys response = await awsClustersClient.GetAwsJsonWebKeysAsync(request);

GetAwsJsonWebKeysAsync(GetAwsJsonWebKeysRequest, CancellationToken)

public virtual Task<AwsJsonWebKeys> GetAwsJsonWebKeysAsync(GetAwsJsonWebKeysRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GetAwsJsonWebKeysRequest request = new GetAwsJsonWebKeysRequest
{
    AwsClusterAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
AwsJsonWebKeys response = await awsClustersClient.GetAwsJsonWebKeysAsync(request);

GetAwsNodePool(AwsNodePoolName, CallSettings)

public virtual AwsNodePool GetAwsNodePool(AwsNodePoolName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
AwsNodePoolName name = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]");
// Make the request
AwsNodePool response = awsClustersClient.GetAwsNodePool(name);

GetAwsNodePool(GetAwsNodePoolRequest, CallSettings)

public virtual AwsNodePool GetAwsNodePool(GetAwsNodePoolRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
GetAwsNodePoolRequest request = new GetAwsNodePoolRequest
{
    AwsNodePoolName = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]"),
};
// Make the request
AwsNodePool response = awsClustersClient.GetAwsNodePool(request);

GetAwsNodePool(string, CallSettings)

public virtual AwsNodePool GetAwsNodePool(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]/awsNodePools/[AWS_NODE_POOL]";
// Make the request
AwsNodePool response = awsClustersClient.GetAwsNodePool(name);

GetAwsNodePoolAsync(AwsNodePoolName, CallSettings)

public virtual Task<AwsNodePool> GetAwsNodePoolAsync(AwsNodePoolName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsNodePoolName name = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]");
// Make the request
AwsNodePool response = await awsClustersClient.GetAwsNodePoolAsync(name);

GetAwsNodePoolAsync(AwsNodePoolName, CancellationToken)

public virtual Task<AwsNodePool> GetAwsNodePoolAsync(AwsNodePoolName name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsNodePoolName name = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]");
// Make the request
AwsNodePool response = await awsClustersClient.GetAwsNodePoolAsync(name);

GetAwsNodePoolAsync(GetAwsNodePoolRequest, CallSettings)

public virtual Task<AwsNodePool> GetAwsNodePoolAsync(GetAwsNodePoolRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GetAwsNodePoolRequest request = new GetAwsNodePoolRequest
{
    AwsNodePoolName = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]"),
};
// Make the request
AwsNodePool response = await awsClustersClient.GetAwsNodePoolAsync(request);

GetAwsNodePoolAsync(GetAwsNodePoolRequest, CancellationToken)

public virtual Task<AwsNodePool> GetAwsNodePoolAsync(GetAwsNodePoolRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GetAwsNodePoolRequest request = new GetAwsNodePoolRequest
{
    AwsNodePoolName = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]"),
};
// Make the request
AwsNodePool response = await awsClustersClient.GetAwsNodePoolAsync(request);

GetAwsNodePoolAsync(string, CallSettings)

public virtual Task<AwsNodePool> GetAwsNodePoolAsync(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]/awsNodePools/[AWS_NODE_POOL]";
// Make the request
AwsNodePool response = await awsClustersClient.GetAwsNodePoolAsync(name);

GetAwsNodePoolAsync(string, CancellationToken)

public virtual Task<AwsNodePool> GetAwsNodePoolAsync(string name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]/awsNodePools/[AWS_NODE_POOL]";
// Make the request
AwsNodePool response = await awsClustersClient.GetAwsNodePoolAsync(name);

GetAwsOpenIdConfig(GetAwsOpenIdConfigRequest, CallSettings)

public virtual AwsOpenIdConfig GetAwsOpenIdConfig(GetAwsOpenIdConfigRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
GetAwsOpenIdConfigRequest request = new GetAwsOpenIdConfigRequest
{
    AwsClusterAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
AwsOpenIdConfig response = awsClustersClient.GetAwsOpenIdConfig(request);

GetAwsOpenIdConfigAsync(GetAwsOpenIdConfigRequest, CallSettings)

public virtual Task<AwsOpenIdConfig> GetAwsOpenIdConfigAsync(GetAwsOpenIdConfigRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GetAwsOpenIdConfigRequest request = new GetAwsOpenIdConfigRequest
{
    AwsClusterAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
AwsOpenIdConfig response = await awsClustersClient.GetAwsOpenIdConfigAsync(request);

GetAwsOpenIdConfigAsync(GetAwsOpenIdConfigRequest, CancellationToken)

public virtual Task<AwsOpenIdConfig> GetAwsOpenIdConfigAsync(GetAwsOpenIdConfigRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GetAwsOpenIdConfigRequest request = new GetAwsOpenIdConfigRequest
{
    AwsClusterAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
AwsOpenIdConfig response = await awsClustersClient.GetAwsOpenIdConfigAsync(request);

GetAwsServerConfig(AwsServerConfigName, CallSettings)

public virtual AwsServerConfig GetAwsServerConfig(AwsServerConfigName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
AwsServerConfigName name = AwsServerConfigName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
AwsServerConfig response = awsClustersClient.GetAwsServerConfig(name);

GetAwsServerConfig(GetAwsServerConfigRequest, CallSettings)

public virtual AwsServerConfig GetAwsServerConfig(GetAwsServerConfigRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
GetAwsServerConfigRequest request = new GetAwsServerConfigRequest
{
    AwsServerConfigName = AwsServerConfigName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
AwsServerConfig response = awsClustersClient.GetAwsServerConfig(request);

GetAwsServerConfig(string, CallSettings)

public virtual AwsServerConfig GetAwsServerConfig(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsServerConfig";
// Make the request
AwsServerConfig response = awsClustersClient.GetAwsServerConfig(name);

GetAwsServerConfigAsync(AwsServerConfigName, CallSettings)

public virtual Task<AwsServerConfig> GetAwsServerConfigAsync(AwsServerConfigName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsServerConfigName name = AwsServerConfigName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
AwsServerConfig response = await awsClustersClient.GetAwsServerConfigAsync(name);

GetAwsServerConfigAsync(AwsServerConfigName, CancellationToken)

public virtual Task<AwsServerConfig> GetAwsServerConfigAsync(AwsServerConfigName name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsServerConfigName name = AwsServerConfigName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
AwsServerConfig response = await awsClustersClient.GetAwsServerConfigAsync(name);

GetAwsServerConfigAsync(GetAwsServerConfigRequest, CallSettings)

public virtual Task<AwsServerConfig> GetAwsServerConfigAsync(GetAwsServerConfigRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GetAwsServerConfigRequest request = new GetAwsServerConfigRequest
{
    AwsServerConfigName = AwsServerConfigName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
AwsServerConfig response = await awsClustersClient.GetAwsServerConfigAsync(request);

GetAwsServerConfigAsync(GetAwsServerConfigRequest, CancellationToken)

public virtual Task<AwsServerConfig> GetAwsServerConfigAsync(GetAwsServerConfigRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GetAwsServerConfigRequest request = new GetAwsServerConfigRequest
{
    AwsServerConfigName = AwsServerConfigName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
AwsServerConfig response = await awsClustersClient.GetAwsServerConfigAsync(request);

GetAwsServerConfigAsync(string, CallSettings)

public virtual Task<AwsServerConfig> GetAwsServerConfigAsync(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsServerConfig";
// Make the request
AwsServerConfig response = await awsClustersClient.GetAwsServerConfigAsync(name);

GetAwsServerConfigAsync(string, CancellationToken)

public virtual Task<AwsServerConfig> GetAwsServerConfigAsync(string name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsServerConfig";
// Make the request
AwsServerConfig response = await awsClustersClient.GetAwsServerConfigAsync(name);

ListAwsClusters(LocationName, string, int?, CallSettings)

public virtual PagedEnumerable<ListAwsClustersResponse, AwsCluster> ListAwsClusters(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListAwsClustersResponse, AwsCluster> response = awsClustersClient.ListAwsClusters(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (AwsCluster item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListAwsClustersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsCluster item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsCluster> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsCluster item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsClusters(ListAwsClustersRequest, CallSettings)

public virtual PagedEnumerable<ListAwsClustersResponse, AwsCluster> ListAwsClusters(ListAwsClustersRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
ListAwsClustersRequest request = new ListAwsClustersRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedEnumerable<ListAwsClustersResponse, AwsCluster> response = awsClustersClient.ListAwsClusters(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (AwsCluster item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListAwsClustersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsCluster item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsCluster> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsCluster item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsClusters(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListAwsClustersResponse, AwsCluster> ListAwsClusters(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListAwsClustersResponse, AwsCluster> response = awsClustersClient.ListAwsClusters(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (AwsCluster item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListAwsClustersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsCluster item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsCluster> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsCluster item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsClustersAsync(LocationName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListAwsClustersResponse, AwsCluster> ListAwsClustersAsync(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListAwsClustersResponse, AwsCluster> response = awsClustersClient.ListAwsClustersAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AwsCluster item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListAwsClustersResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsCluster item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsCluster> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsCluster item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsClustersAsync(ListAwsClustersRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListAwsClustersResponse, AwsCluster> ListAwsClustersAsync(ListAwsClustersRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
ListAwsClustersRequest request = new ListAwsClustersRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedAsyncEnumerable<ListAwsClustersResponse, AwsCluster> response = awsClustersClient.ListAwsClustersAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AwsCluster item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListAwsClustersResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsCluster item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsCluster> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsCluster item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsClustersAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListAwsClustersResponse, AwsCluster> ListAwsClustersAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListAwsClustersResponse, AwsCluster> response = awsClustersClient.ListAwsClustersAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AwsCluster item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListAwsClustersResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsCluster item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsCluster> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsCluster item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsNodePools(AwsClusterName, string, int?, CallSettings)

public virtual PagedEnumerable<ListAwsNodePoolsResponse, AwsNodePool> ListAwsNodePools(AwsClusterName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
AwsClusterName parent = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
// Make the request
PagedEnumerable<ListAwsNodePoolsResponse, AwsNodePool> response = awsClustersClient.ListAwsNodePools(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (AwsNodePool item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListAwsNodePoolsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsNodePool item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsNodePool> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsNodePool item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsNodePools(ListAwsNodePoolsRequest, CallSettings)

public virtual PagedEnumerable<ListAwsNodePoolsResponse, AwsNodePool> ListAwsNodePools(ListAwsNodePoolsRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
ListAwsNodePoolsRequest request = new ListAwsNodePoolsRequest
{
    ParentAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
PagedEnumerable<ListAwsNodePoolsResponse, AwsNodePool> response = awsClustersClient.ListAwsNodePools(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (AwsNodePool item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListAwsNodePoolsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsNodePool item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsNodePool> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsNodePool item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsNodePools(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListAwsNodePoolsResponse, AwsNodePool> ListAwsNodePools(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
// Make the request
PagedEnumerable<ListAwsNodePoolsResponse, AwsNodePool> response = awsClustersClient.ListAwsNodePools(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (AwsNodePool item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListAwsNodePoolsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsNodePool item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsNodePool> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsNodePool item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsNodePoolsAsync(AwsClusterName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListAwsNodePoolsResponse, AwsNodePool> ListAwsNodePoolsAsync(AwsClusterName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsClusterName parent = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
// Make the request
PagedAsyncEnumerable<ListAwsNodePoolsResponse, AwsNodePool> response = awsClustersClient.ListAwsNodePoolsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AwsNodePool item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListAwsNodePoolsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsNodePool item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsNodePool> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsNodePool item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsNodePoolsAsync(ListAwsNodePoolsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListAwsNodePoolsResponse, AwsNodePool> ListAwsNodePoolsAsync(ListAwsNodePoolsRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
ListAwsNodePoolsRequest request = new ListAwsNodePoolsRequest
{
    ParentAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
PagedAsyncEnumerable<ListAwsNodePoolsResponse, AwsNodePool> response = awsClustersClient.ListAwsNodePoolsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AwsNodePool item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListAwsNodePoolsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsNodePool item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsNodePool> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsNodePool item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsNodePoolsAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListAwsNodePoolsResponse, AwsNodePool> ListAwsNodePoolsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
// Make the request
PagedAsyncEnumerable<ListAwsNodePoolsResponse, AwsNodePool> response = awsClustersClient.ListAwsNodePoolsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AwsNodePool item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListAwsNodePoolsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsNodePool item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsNodePool> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsNodePool item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

PollOnceCreateAwsCluster(string, CallSettings)

public virtual Operation<AwsCluster, OperationMetadata> PollOnceCreateAwsCluster(string operationName, CallSettings callSettings = null)

PollOnceCreateAwsClusterAsync(string, CallSettings)

public virtual Task<Operation<AwsCluster, OperationMetadata>> PollOnceCreateAwsClusterAsync(string operationName, CallSettings callSettings = null)

PollOnceCreateAwsNodePool(string, CallSettings)

public virtual Operation<AwsNodePool, OperationMetadata> PollOnceCreateAwsNodePool(string operationName, CallSettings callSettings = null)

PollOnceCreateAwsNodePoolAsync(string, CallSettings)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> PollOnceCreateAwsNodePoolAsync(string operationName, CallSettings callSettings = null)

PollOnceDeleteAwsCluster(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> PollOnceDeleteAwsCluster(string operationName, CallSettings callSettings = null)

PollOnceDeleteAwsClusterAsync(string, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> PollOnceDeleteAwsClusterAsync(string operationName, CallSettings callSettings = null)

PollOnceDeleteAwsNodePool(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> PollOnceDeleteAwsNodePool(string operationName, CallSettings callSettings = null)

PollOnceDeleteAwsNodePoolAsync(string, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> PollOnceDeleteAwsNodePoolAsync(string operationName, CallSettings callSettings = null)

PollOnceRollbackAwsNodePoolUpdate(string, CallSettings)

public virtual Operation<AwsNodePool, OperationMetadata> PollOnceRollbackAwsNodePoolUpdate(string operationName, CallSettings callSettings = null)

PollOnceRollbackAwsNodePoolUpdateAsync(string, CallSettings)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> PollOnceRollbackAwsNodePoolUpdateAsync(string operationName, CallSettings callSettings = null)

PollOnceUpdateAwsCluster(string, CallSettings)

public virtual Operation<AwsCluster, OperationMetadata> PollOnceUpdateAwsCluster(string operationName, CallSettings callSettings = null)

PollOnceUpdateAwsClusterAsync(string, CallSettings)

public virtual Task<Operation<AwsCluster, OperationMetadata>> PollOnceUpdateAwsClusterAsync(string operationName, CallSettings callSettings = null)

PollOnceUpdateAwsNodePool(string, CallSettings)

public virtual Operation<AwsNodePool, OperationMetadata> PollOnceUpdateAwsNodePool(string operationName, CallSettings callSettings = null)

PollOnceUpdateAwsNodePoolAsync(string, CallSettings)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> PollOnceUpdateAwsNodePoolAsync(string operationName, CallSettings callSettings = null)

RollbackAwsNodePoolUpdate(AwsNodePoolName, CallSettings)

public virtual Operation<AwsNodePool, OperationMetadata> RollbackAwsNodePoolUpdate(AwsNodePoolName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
AwsNodePoolName name = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]");
// Make the request
Operation<AwsNodePool, OperationMetadata> response = awsClustersClient.RollbackAwsNodePoolUpdate(name);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceRollbackAwsNodePoolUpdate(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

RollbackAwsNodePoolUpdate(RollbackAwsNodePoolUpdateRequest, CallSettings)

public virtual Operation<AwsNodePool, OperationMetadata> RollbackAwsNodePoolUpdate(RollbackAwsNodePoolUpdateRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
RollbackAwsNodePoolUpdateRequest request = new RollbackAwsNodePoolUpdateRequest
{
    AwsNodePoolName = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]"),
    RespectPdb = false,
};
// Make the request
Operation<AwsNodePool, OperationMetadata> response = awsClustersClient.RollbackAwsNodePoolUpdate(request);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceRollbackAwsNodePoolUpdate(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

RollbackAwsNodePoolUpdate(string, CallSettings)

public virtual Operation<AwsNodePool, OperationMetadata> RollbackAwsNodePoolUpdate(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]/awsNodePools/[AWS_NODE_POOL]";
// Make the request
Operation<AwsNodePool, OperationMetadata> response = awsClustersClient.RollbackAwsNodePoolUpdate(name);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceRollbackAwsNodePoolUpdate(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

RollbackAwsNodePoolUpdateAsync(AwsNodePoolName, CallSettings)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> RollbackAwsNodePoolUpdateAsync(AwsNodePoolName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsNodePoolName name = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]");
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.RollbackAwsNodePoolUpdateAsync(name);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceRollbackAwsNodePoolUpdateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

RollbackAwsNodePoolUpdateAsync(AwsNodePoolName, CancellationToken)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> RollbackAwsNodePoolUpdateAsync(AwsNodePoolName name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsNodePoolName name = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]");
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.RollbackAwsNodePoolUpdateAsync(name);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceRollbackAwsNodePoolUpdateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

RollbackAwsNodePoolUpdateAsync(RollbackAwsNodePoolUpdateRequest, CallSettings)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> RollbackAwsNodePoolUpdateAsync(RollbackAwsNodePoolUpdateRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
RollbackAwsNodePoolUpdateRequest request = new RollbackAwsNodePoolUpdateRequest
{
    AwsNodePoolName = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]"),
    RespectPdb = false,
};
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.RollbackAwsNodePoolUpdateAsync(request);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceRollbackAwsNodePoolUpdateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

RollbackAwsNodePoolUpdateAsync(RollbackAwsNodePoolUpdateRequest, CancellationToken)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> RollbackAwsNodePoolUpdateAsync(RollbackAwsNodePoolUpdateRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
RollbackAwsNodePoolUpdateRequest request = new RollbackAwsNodePoolUpdateRequest
{
    AwsNodePoolName = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]"),
    RespectPdb = false,
};
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.RollbackAwsNodePoolUpdateAsync(request);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceRollbackAwsNodePoolUpdateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

RollbackAwsNodePoolUpdateAsync(string, CallSettings)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> RollbackAwsNodePoolUpdateAsync(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]/awsNodePools/[AWS_NODE_POOL]";
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.RollbackAwsNodePoolUpdateAsync(name);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceRollbackAwsNodePoolUpdateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

RollbackAwsNodePoolUpdateAsync(string, CancellationToken)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> RollbackAwsNodePoolUpdateAsync(string name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]/awsNodePools/[AWS_NODE_POOL]";
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.RollbackAwsNodePoolUpdateAsync(name);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceRollbackAwsNodePoolUpdateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

ShutdownDefaultChannelsAsync()

public static Task ShutdownDefaultChannelsAsync()

UpdateAwsCluster(AwsCluster, FieldMask, CallSettings)

public virtual Operation<AwsCluster, OperationMetadata> UpdateAwsCluster(AwsCluster awsCluster, FieldMask updateMask, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
AwsCluster awsCluster = new AwsCluster();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<AwsCluster, OperationMetadata> response = awsClustersClient.UpdateAwsCluster(awsCluster, updateMask);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceUpdateAwsCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

UpdateAwsCluster(UpdateAwsClusterRequest, CallSettings)

public virtual Operation<AwsCluster, OperationMetadata> UpdateAwsCluster(UpdateAwsClusterRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
UpdateAwsClusterRequest request = new UpdateAwsClusterRequest
{
    AwsCluster = new AwsCluster(),
    ValidateOnly = false,
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<AwsCluster, OperationMetadata> response = awsClustersClient.UpdateAwsCluster(request);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceUpdateAwsCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

UpdateAwsClusterAsync(AwsCluster, FieldMask, CallSettings)

public virtual Task<Operation<AwsCluster, OperationMetadata>> UpdateAwsClusterAsync(AwsCluster awsCluster, FieldMask updateMask, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsCluster awsCluster = new AwsCluster();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<AwsCluster, OperationMetadata> response = await awsClustersClient.UpdateAwsClusterAsync(awsCluster, updateMask);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceUpdateAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

UpdateAwsClusterAsync(AwsCluster, FieldMask, CancellationToken)

public virtual Task<Operation<AwsCluster, OperationMetadata>> UpdateAwsClusterAsync(AwsCluster awsCluster, FieldMask updateMask, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsCluster awsCluster = new AwsCluster();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<AwsCluster, OperationMetadata> response = await awsClustersClient.UpdateAwsClusterAsync(awsCluster, updateMask);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceUpdateAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

UpdateAwsClusterAsync(UpdateAwsClusterRequest, CallSettings)

public virtual Task<Operation<AwsCluster, OperationMetadata>> UpdateAwsClusterAsync(UpdateAwsClusterRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
UpdateAwsClusterRequest request = new UpdateAwsClusterRequest
{
    AwsCluster = new AwsCluster(),
    ValidateOnly = false,
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<AwsCluster, OperationMetadata> response = await awsClustersClient.UpdateAwsClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceUpdateAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

UpdateAwsClusterAsync(UpdateAwsClusterRequest, CancellationToken)

public virtual Task<Operation<AwsCluster, OperationMetadata>> UpdateAwsClusterAsync(UpdateAwsClusterRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
UpdateAwsClusterRequest request = new UpdateAwsClusterRequest
{
    AwsCluster = new AwsCluster(),
    ValidateOnly = false,
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<AwsCluster, OperationMetadata> response = await awsClustersClient.UpdateAwsClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceUpdateAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

UpdateAwsNodePool(AwsNodePool, FieldMask, CallSettings)

public virtual Operation<AwsNodePool, OperationMetadata> UpdateAwsNodePool(AwsNodePool awsNodePool, FieldMask updateMask, CallSettings callSettings = null)