Schema
data class SchemaArgs(val content: Output<String>? = null, val description: Output<String>? = null, val name: Output<String>? = null, val registryName: Output<String>? = null, val tags: Output<Map<String, String>>? = null, val type: Output<String>? = null) : ConvertibleToJava<SchemaArgs>
Provides an EventBridge Schema resource.
Note: EventBridge was formerly known as CloudWatch Events. The functionality is identical.
Example Usage
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const test = new aws.schemas.Registry("test", {name: "my_own_registry"});
const testSchema = new aws.schemas.Schema("test", {
name: "my_schema",
registryName: test.name,
type: "OpenApi3",
description: "The schema definition for my event",
content: JSON.stringify({
openapi: "3.0.0",
info: {
version: "1.0.0",
title: "Event",
},
paths: {},
components: {
schemas: {
Event: {
type: "object",
properties: {
name: {
type: "string",
},
},
},
},
},
}),
});Content copied to clipboard
import pulumi
import json
import pulumi_aws as aws
test = aws.schemas.Registry("test", name="my_own_registry")
test_schema = aws.schemas.Schema("test",
name="my_schema",
registry_name=test.name,
type="OpenApi3",
description="The schema definition for my event",
content=json.dumps({
"openapi": "3.0.0",
"info": {
"version": "1.0.0",
"title": "Event",
},
"paths": {},
"components": {
"schemas": {
"Event": {
"type": "object",
"properties": {
"name": {
"type": "string",
},
},
},
},
},
}))Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var test = new Aws.Schemas.Registry("test", new()
{
Name = "my_own_registry",
});
var testSchema = new Aws.Schemas.Schema("test", new()
{
Name = "my_schema",
RegistryName = test.Name,
Type = "OpenApi3",
Description = "The schema definition for my event",
Content = JsonSerializer.Serialize(new Dictionary<string, object?>
{
["openapi"] = "3.0.0",
["info"] = new Dictionary<string, object?>
{
["version"] = "1.0.0",
["title"] = "Event",
},
["paths"] = new Dictionary<string, object?>
{
},
["components"] = new Dictionary<string, object?>
{
["schemas"] = new Dictionary<string, object?>
{
["Event"] = new Dictionary<string, object?>
{
["type"] = "object",
["properties"] = new Dictionary<string, object?>
{
["name"] = new Dictionary<string, object?>
{
["type"] = "string",
},
},
},
},
},
}),
});
});Content copied to clipboard
package main
import (
"encoding/json"
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/schemas"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
test, err := schemas.NewRegistry(ctx, "test", &schemas.RegistryArgs{
Name: pulumi.String("my_own_registry"),
})
if err != nil {
return err
}
tmpJSON0, err := json.Marshal(map[string]interface{}{
"openapi": "3.0.0",
"info": map[string]interface{}{
"version": "1.0.0",
"title": "Event",
},
"paths": map[string]interface{}{},
"components": map[string]interface{}{
"schemas": map[string]interface{}{
"Event": map[string]interface{}{
"type": "object",
"properties": map[string]interface{}{
"name": map[string]interface{}{
"type": "string",
},
},
},
},
},
})
if err != nil {
return err
}
json0 := string(tmpJSON0)
_, err = schemas.NewSchema(ctx, "test", &schemas.SchemaArgs{
Name: pulumi.String("my_schema"),
RegistryName: test.Name,
Type: pulumi.String("OpenApi3"),
Description: pulumi.String("The schema definition for my event"),
Content: pulumi.String(json0),
})
if err != nil {
return err
}
return nil
})
}Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.schemas.Registry;
import com.pulumi.aws.schemas.RegistryArgs;
import com.pulumi.aws.schemas.Schema;
import com.pulumi.aws.schemas.SchemaArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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 test = new Registry("test", RegistryArgs.builder()
.name("my_own_registry")
.build());
var testSchema = new Schema("testSchema", SchemaArgs.builder()
.name("my_schema")
.registryName(test.name())
.type("OpenApi3")
.description("The schema definition for my event")
.content(serializeJson(
jsonObject(
jsonProperty("openapi", "3.0.0"),
jsonProperty("info", jsonObject(
jsonProperty("version", "1.0.0"),
jsonProperty("title", "Event")
)),
jsonProperty("paths", jsonObject(
)),
jsonProperty("components", jsonObject(
jsonProperty("schemas", jsonObject(
jsonProperty("Event", jsonObject(
jsonProperty("type", "object"),
jsonProperty("properties", jsonObject(
jsonProperty("name", jsonObject(
jsonProperty("type", "string")
))
))
))
))
))
)))
.build());
}
}Content copied to clipboard
resources:
test:
type: aws:schemas:Registry
properties:
name: my_own_registry
testSchema:
type: aws:schemas:Schema
name: test
properties:
name: my_schema
registryName: ${test.name}
type: OpenApi3
description: The schema definition for my event
content:
fn::toJSON:
openapi: 3.0.0
info:
version: 1.0.0
title: Event
paths: {}
components:
schemas:
Event:
type: object
properties:
name:
type: stringContent copied to clipboard
Import
Using pulumi import, import EventBridge schema using the name and registry_name. For example:
$ pulumi import aws:schemas/schema:Schema test name/registryContent copied to clipboard