checkpoint.getManagementAwsDataCenterServer

import * as pulumi from "@pulumi/pulumi";
import * as checkpoint from "@pulumi/checkpoint";

const testAws = new checkpoint.ManagementAwsDataCenterServer("testAws", {
    accessKeyId: "MY-KEY-ID",
    authenticationMethod: "user-authentication",
    region: "us-east-1",
    secretAccessKey: "MY-SECRET-KEY",
});
const dataAwsDataCenterServer = checkpoint.getManagementAwsDataCenterServerOutput({
    name: testAws.name,
});

import pulumi
import pulumi_checkpoint as checkpoint

test_aws = checkpoint.ManagementAwsDataCenterServer("testAws",
    access_key_id="MY-KEY-ID",
    authentication_method="user-authentication",
    region="us-east-1",
    secret_access_key="MY-SECRET-KEY")
data_aws_data_center_server = checkpoint.get_management_aws_data_center_server_output(name=test_aws.name)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/checkpoint/v2/checkpoint"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		testAws, err := checkpoint.NewManagementAwsDataCenterServer(ctx, "testAws", &checkpoint.ManagementAwsDataCenterServerArgs{
			AccessKeyId:          pulumi.String("MY-KEY-ID"),
			AuthenticationMethod: pulumi.String("user-authentication"),
			Region:               pulumi.String("us-east-1"),
			SecretAccessKey:      pulumi.String("MY-SECRET-KEY"),
		})
		if err != nil {
			return err
		}
		_ = checkpoint.LookupManagementAwsDataCenterServerOutput(ctx, checkpoint.GetManagementAwsDataCenterServerOutputArgs{
			Name: testAws.Name,
		}, nil)
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Checkpoint = Pulumi.Checkpoint;

return await Deployment.RunAsync(() => 
{
    var testAws = new Checkpoint.ManagementAwsDataCenterServer("testAws", new()
    {
        AccessKeyId = "MY-KEY-ID",
        AuthenticationMethod = "user-authentication",
        Region = "us-east-1",
        SecretAccessKey = "MY-SECRET-KEY",
    });

    var dataAwsDataCenterServer = Checkpoint.GetManagementAwsDataCenterServer.Invoke(new()
    {
        Name = testAws.Name,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.checkpoint.ManagementAwsDataCenterServer;
import com.pulumi.checkpoint.ManagementAwsDataCenterServerArgs;
import com.pulumi.checkpoint.CheckpointFunctions;
import com.pulumi.checkpoint.inputs.GetManagementAwsDataCenterServerArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var testAws = new ManagementAwsDataCenterServer("testAws", ManagementAwsDataCenterServerArgs.builder()
            .accessKeyId("MY-KEY-ID")
            .authenticationMethod("user-authentication")
            .region("us-east-1")
            .secretAccessKey("MY-SECRET-KEY")
            .build());

        final var dataAwsDataCenterServer = CheckpointFunctions.getManagementAwsDataCenterServer(GetManagementAwsDataCenterServerArgs.builder()
            .name(testAws.name())
            .build());

    }
}

resources:
  testAws:
    type: checkpoint:ManagementAwsDataCenterServer
    properties:
      accessKeyId: MY-KEY-ID
      authenticationMethod: user-authentication
      region: us-east-1
      secretAccessKey: MY-SECRET-KEY
variables:
  dataAwsDataCenterServer:
    fn::invoke:
      function: checkpoint:getManagementAwsDataCenterServer
      arguments:
        name: ${testAws.name}

function getManagementAwsDataCenterServer(args: GetManagementAwsDataCenterServerArgs, opts?: InvokeOptions): Promise<GetManagementAwsDataCenterServerResult>
function getManagementAwsDataCenterServerOutput(args: GetManagementAwsDataCenterServerOutputArgs, opts?: InvokeOptions): Output<GetManagementAwsDataCenterServerResult>

def get_management_aws_data_center_server(id: Optional[str] = None,
                                          name: Optional[str] = None,
                                          uid: Optional[str] = None,
                                          opts: Optional[InvokeOptions] = None) -> GetManagementAwsDataCenterServerResult
def get_management_aws_data_center_server_output(id: Optional[pulumi.Input[str]] = None,
                                          name: Optional[pulumi.Input[str]] = None,
                                          uid: Optional[pulumi.Input[str]] = None,
                                          opts: Optional[InvokeOptions] = None) -> Output[GetManagementAwsDataCenterServerResult]

func LookupManagementAwsDataCenterServer(ctx *Context, args *LookupManagementAwsDataCenterServerArgs, opts ...InvokeOption) (*LookupManagementAwsDataCenterServerResult, error)
func LookupManagementAwsDataCenterServerOutput(ctx *Context, args *LookupManagementAwsDataCenterServerOutputArgs, opts ...InvokeOption) LookupManagementAwsDataCenterServerResultOutput

public static class GetManagementAwsDataCenterServer 
{
    public static Task<GetManagementAwsDataCenterServerResult> InvokeAsync(GetManagementAwsDataCenterServerArgs args, InvokeOptions? opts = null)
    public static Output<GetManagementAwsDataCenterServerResult> Invoke(GetManagementAwsDataCenterServerInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetManagementAwsDataCenterServerResult> getManagementAwsDataCenterServer(GetManagementAwsDataCenterServerArgs args, InvokeOptions options)
public static Output<GetManagementAwsDataCenterServerResult> getManagementAwsDataCenterServer(GetManagementAwsDataCenterServerArgs args, InvokeOptions options)

fn::invoke:
  function: checkpoint:index/getManagementAwsDataCenterServer:getManagementAwsDataCenterServer
  arguments:
    # arguments dictionary