portableresources

Documentation

Index

• Constants
• func IsValidPortableResourceType(resourceType string) bool
• type Kubernetes
• type RecipeContext
• type RecipeData
• type RecipeProperties
• type Resource
• type ResourceInfo
• type ResourceProvisioning
• type ResourceRecipe
• type ResourceReference
• type Runtime

Constants

const (
	// DaprPubSubBrokersResourceType represents the resource type for Dapr PubSub brokers.
	DaprPubSubBrokersResourceType = "Applications.Dapr/pubSubBrokers"

	// DaprSecretStoresResourceType represents the resource type for Dapr Secret stores.
	DaprSecretStoresResourceType = "Applications.Dapr/secretStores"

	// DaprStateStoresResourceType represents the resource type for Dapr State stores.
	DaprStateStoresResourceType = "Applications.Dapr/stateStores"

	// RabbitMQQueuesResourceType represents the resource type for RabbitMQ queue.
	RabbitMQQueuesResourceType = "Applications.Messaging/rabbitMQQueues"

	// MongoDatabasesResourceType represents the resource type for Mongo database.
	MongoDatabasesResourceType = "Applications.Datastores/mongoDatabases"

	// RedisCachesResourceType represents the resource type for Redis caches.
	RedisCachesResourceType = "Applications.Datastores/redisCaches"

	// SqlDatabasesResourceType represents the resource type for SQL databases.
	SqlDatabasesResourceType = "Applications.Datastores/sqlDatabases"

	// ExtendersResourceType represents the resource type for Extenders resource.
	ExtendersResourceType = "Applications.Core/extenders"

	// ResourceProvisioningRecipe is the scenario when Radius manages the lifecycle of the resource through a Recipe.
	ResourceProvisioningRecipe ResourceProvisioning = "recipe"

	// ResourceProvisioningManual is the scenario where the user manages the resource and provides values.
	ResourceProvisioningManual ResourceProvisioning = "manual"

	// DefaultRecipeName represents the default recipe name.
	DefaultRecipeName = "default"
)

Functions

func IsValidPortableResourceType

func IsValidPortableResourceType(resourceType string) bool

IsValidPortableResourceType checks if the provided resource type is a valid portable resource type. Returns true if the resource type is valid, false otherwise.

Types

type Kubernetes

type Kubernetes struct {
	// Namespace is set to the applicationNamespace when the portable resource is application-scoped, and set to the environmentNamespace when it is environment scoped
	Namespace string `json:"namespace"`
	// EnvironmentNamespace is set to environment namespace.
	EnvironmentNamespace string `json:"environmentNamespace"`
}

type RecipeContext

type RecipeContext struct {
	Resource    Resource     `json:"resource,omitempty"`
	Application ResourceInfo `json:"application,omitempty"`
	Environment ResourceInfo `json:"environment,omitempty"`
	Runtime     Runtime      `json:"runtime,omitempty"`
}

RecipeContext Recipe template authors can leverage the RecipeContext parameter to access portable resource properties to generate name and properties that are unique for the resource calling the recipe.

type RecipeData

type RecipeData struct {
	RecipeProperties

	// APIVersion is the API version to use to perform operations on resources.
	// For example for Azure resources, every service has different REST API version that must be specified in the request.
	APIVersion string

	// Resource ids of the resources deployed by the recipe
	Resources []string
}

type RecipeProperties

type RecipeProperties struct {
	ResourceRecipe                // ResourceRecipe is the recipe of the resource to be deployed
	ResourceType   string         // ResourceType represent the type of the resource
	TemplatePath   string         // TemplatePath represent the recipe location
	EnvParameters  map[string]any // EnvParameters represents the parameters set by the operator while linking the recipe to an environment
}

RecipeProperties represents the information needed to deploy a recipe

type Resource

type Resource struct {
	ResourceInfo
	Type string `json:"type"`
}

Resource contains the information needed to deploy a recipe. In the case the resource is a portable resource, it represents the resource's id, name and type.

type ResourceInfo

type ResourceInfo struct {
	Name string `json:"name"`
	ID   string `json:"id"`
}

ResourceInfo name and id of the resource

type ResourceProvisioning

type ResourceProvisioning string

ResourceProvisioning specifies how the resource should be managed

type ResourceRecipe

type ResourceRecipe struct {
	// Name of the recipe within the environment to use
	Name string `json:"name,omitempty"`
	// Parameters are key/value parameters to pass into the recipe at deployment
	Parameters map[string]any `json:"parameters,omitempty"`
	// DeploymentStatus is the deployment status of the recipe
	DeploymentStatus util.RecipeDeploymentStatus `json:"recipeStatus,omitempty"`
}

ResourceRecipe is the recipe details used to automatically deploy underlying infrastructure for a resource.

type ResourceReference

type ResourceReference struct {
	ID string `json:"id"`
}

ResourceReference represents a reference to a resource that was deployed by the user and specified as part of a portable resource.

This type should be used in datamodels for the '.properties.resources' field.

type Runtime

type Runtime struct {
	Kubernetes Kubernetes `json:"kubernetes,omitempty"`
}