getEndpoint function

Future<GetEndpointResult> getEndpoint(
  1. GetEndpointArgs args, {
  2. InvokeOptions? options,
})

Returns a unique endpoint specific to the AWS account making the call.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as kubernetes from "@pulumi/kubernetes";

const example = aws.iot.getEndpoint({});
const agent = new kubernetes.index.Pod("agent", {
    metadata: [{
        name: "my-device",
    }],
    spec: [{
        container: [{
            env: [{
                name: "IOT_ENDPOINT",
                value: example.endpointAddress,
            }],
            image: "gcr.io/my-project/image-name",
            name: "image-name",
        }],
    }],
});
import pulumi
import pulumi_aws as aws
import pulumi_kubernetes as kubernetes

example = aws.iot.get_endpoint()
agent = kubernetes.Pod("agent",
    metadata=[{
        name: my-device,
    }],
    spec=[{
        container: [{
            env: [{
                name: IOT_ENDPOINT,
                value: example.endpoint_address,
            }],
            image: gcr.io/my-project/image-name,
            name: image-name,
        }],
    }])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using Kubernetes = Pulumi.Kubernetes;

return await Deployment.RunAsync(() =>
{
    var example = Aws.Iot.GetEndpoint.Invoke();

    var agent = new Kubernetes.Pod("agent", new()
    {
        Metadata = new[]
        {

            {
                { "name", "my-device" },
            },
        },
        Spec = new[]
        {

            {
                { "container", new[]
                {

                    {
                        { "env", new[]
                        {

                            {
                                { "name", "IOT_ENDPOINT" },
                                { "value", example.Apply(getEndpointResult => getEndpointResult.EndpointAddress) },
                            },
                        } },
                        { "image", "gcr.io/my-project/image-name" },
                        { "name", "image-name" },
                    },
                } },
            },
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iot"
	"github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := iot.GetEndpoint(ctx, &iot.GetEndpointArgs{}, nil)
		if err != nil {
			return err
		}
		_, err = kubernetes.NewPod(ctx, "agent", &kubernetes.PodArgs{
			Metadata: []map[string]string{
				{
					"name": "my-device",
				},
			},
			Spec: []map[string][]map[string]interface{}{
				map[string][]map[string]interface{}{
					"container": []map[string]interface{}{
						map[string]interface{}{
							"env": []map[string]interface{}{
								map[string]interface{}{
									"name":  "IOT_ENDPOINT",
									"value": example.EndpointAddress,
								},
							},
							"image": "gcr.io/my-project/image-name",
							"name":  "image-name",
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
    kubernetes = {
      source = "pulumi/kubernetes"
    }
  }
}

data "aws_iot_getendpoint" "example" {
}

resource "kubernetes_pod" "agent" {
  metadata = [{
    "name" = "my-device"
  }]
  spec = [{
    "container" = [{
      "env" = [{
        "name"  = "IOT_ENDPOINT"
        "value" = data.aws_iot_getendpoint.example.endpoint_address
      }]
      "image" = "gcr.io/my-project/image-name"
      "name"  = "image-name"
    }]
  }]
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.iot.IotFunctions;
import com.pulumi.aws.iot.inputs.GetEndpointArgs;
import com.pulumi.kubernetes.Pod;
import com.pulumi.kubernetes.PodArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        final var example = IotFunctions.getEndpoint(GetEndpointArgs.builder()
            .build());

        var agent = new Pod("agent", PodArgs.builder()
            .metadata(Arrays.asList(Map.of("name", "my-device")))
            .spec(Arrays.asList(Map.of("container", Arrays.asList(Map.ofEntries(
                Map.entry("env", Arrays.asList(Map.ofEntries(
                    Map.entry("name", "IOT_ENDPOINT"),
                    Map.entry("value", example.endpointAddress())
                ))),
                Map.entry("image", "gcr.io/my-project/image-name"),
                Map.entry("name", "image-name")
            )))))
            .build());

    }
}
resources:
  agent:
    type: kubernetes:Pod
    properties:
      metadata:
        - name: my-device
      spec:
        - container:
            - env:
                - name: IOT_ENDPOINT
                  value: ${example.endpointAddress}
              image: gcr.io/my-project/image-name
              name: image-name
variables:
  example:
    fn::invoke:
      function: aws:iot:getEndpoint
      arguments: {}

args Arguments passed to this invoke. Arguments for getEndpoint. options Invoke options controlling this call.

Implementation

Future<GetEndpointResult> getEndpoint(
  GetEndpointArgs args, {
  pulumi.InvokeOptions? options,
}) async {
  final deployment = pulumi.Deployment.instance;
  final result = await deployment.invoke<Map<String, dynamic>>(
    'aws:iot/getEndpoint:getEndpoint',
    args.toMap(),
    options: pulumi.toDeploymentInvokeOptions(options),
  );
  return GetEndpointResult.fromMap(result);
}