privateendpointconnections

package
v0.20240903.1111904 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 3, 2024 License: MPL-2.0 Imports: 13 Imported by: 1

README

github.com/hashicorp/go-azure-sdk/resource-manager/containerapps/2024-02-02-preview/privateendpointconnections Documentation

The privateendpointconnections SDK allows for interaction with the Azure Resource Manager Service containerapps (API Version 2024-02-02-preview).

This readme covers example usages, but further information on using this SDK can be found in the project root.

Import Path

import "github.com/hashicorp/go-azure-sdk/resource-manager/containerapps/2024-02-02-preview/privateendpointconnections"

Client Initialization

client := privateendpointconnections.NewPrivateEndpointConnectionsClientWithBaseURI("https://management.azure.com")
client.Client.Authorizer = authorizer

Example Usage: PrivateEndpointConnectionsClient.ManagedEnvironmentPrivateEndpointConnectionsCreateOrUpdate

ctx := context.TODO()
id := privateendpointconnections.NewPrivateEndpointConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "managedEnvironmentValue", "privateEndpointConnectionValue")

payload := privateendpointconnections.PrivateEndpointConnection{
	// ...
}


if err := client.ManagedEnvironmentPrivateEndpointConnectionsCreateOrUpdateThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: PrivateEndpointConnectionsClient.ManagedEnvironmentPrivateEndpointConnectionsDelete

ctx := context.TODO()
id := privateendpointconnections.NewPrivateEndpointConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "managedEnvironmentValue", "privateEndpointConnectionValue")

if err := client.ManagedEnvironmentPrivateEndpointConnectionsDeleteThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: PrivateEndpointConnectionsClient.ManagedEnvironmentPrivateEndpointConnectionsGet

ctx := context.TODO()
id := privateendpointconnections.NewPrivateEndpointConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "managedEnvironmentValue", "privateEndpointConnectionValue")

read, err := client.ManagedEnvironmentPrivateEndpointConnectionsGet(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: PrivateEndpointConnectionsClient.ManagedEnvironmentPrivateEndpointConnectionsList

ctx := context.TODO()
id := privateendpointconnections.NewManagedEnvironmentID("12345678-1234-9876-4563-123456789012", "example-resource-group", "managedEnvironmentValue")

// alternatively `client.ManagedEnvironmentPrivateEndpointConnectionsList(ctx, id)` can be used to do batched pagination
items, err := client.ManagedEnvironmentPrivateEndpointConnectionsListComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func PossibleValuesForPrivateEndpointConnectionProvisioningState 

func PossibleValuesForPrivateEndpointConnectionProvisioningState() []string

func PossibleValuesForPrivateEndpointServiceConnectionStatus 

func PossibleValuesForPrivateEndpointServiceConnectionStatus() []string

func ValidateManagedEnvironmentID 

func ValidateManagedEnvironmentID(input interface{}, key string) (warnings []string, errors []error)

ValidateManagedEnvironmentID checks that 'input' can be parsed as a Managed Environment ID

func ValidatePrivateEndpointConnectionID 

func ValidatePrivateEndpointConnectionID(input interface{}, key string) (warnings []string, errors []error)

ValidatePrivateEndpointConnectionID checks that 'input' can be parsed as a Private Endpoint Connection ID

Types

type ManagedEnvironmentId 

type ManagedEnvironmentId struct {
	SubscriptionId         string
	ResourceGroupName      string
	ManagedEnvironmentName string
}

ManagedEnvironmentId is a struct representing the Resource ID for a Managed Environment

func NewManagedEnvironmentID 

func NewManagedEnvironmentID(subscriptionId string, resourceGroupName string, managedEnvironmentName string) ManagedEnvironmentId

NewManagedEnvironmentID returns a new ManagedEnvironmentId struct

func ParseManagedEnvironmentID 

func ParseManagedEnvironmentID(input string) (*ManagedEnvironmentId, error)

ParseManagedEnvironmentID parses 'input' into a ManagedEnvironmentId

func ParseManagedEnvironmentIDInsensitively 

func ParseManagedEnvironmentIDInsensitively(input string) (*ManagedEnvironmentId, error)

ParseManagedEnvironmentIDInsensitively parses 'input' case-insensitively into a ManagedEnvironmentId note: this method should only be used for API response data and not user input

func (*ManagedEnvironmentId) FromParseResult 

func (id *ManagedEnvironmentId) FromParseResult(input resourceids.ParseResult) error

func (ManagedEnvironmentId) ID 

func (id ManagedEnvironmentId) ID() string

ID returns the formatted Managed Environment ID

func (ManagedEnvironmentId) Segments 

func (id ManagedEnvironmentId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Managed Environment ID

func (ManagedEnvironmentId) String 

func (id ManagedEnvironmentId) String() string

String returns a human-readable description of this Managed Environment ID

type ManagedEnvironmentPrivateEndpointConnectionsCreateOrUpdateOperationResponse 

type ManagedEnvironmentPrivateEndpointConnectionsCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *PrivateEndpointConnection
}

type ManagedEnvironmentPrivateEndpointConnectionsDeleteOperationResponse 

type ManagedEnvironmentPrivateEndpointConnectionsDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type ManagedEnvironmentPrivateEndpointConnectionsGetOperationResponse 

type ManagedEnvironmentPrivateEndpointConnectionsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *PrivateEndpointConnection
}

type ManagedEnvironmentPrivateEndpointConnectionsListCompleteResult 

type ManagedEnvironmentPrivateEndpointConnectionsListCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []PrivateEndpointConnection
}

type ManagedEnvironmentPrivateEndpointConnectionsListCustomPager 

type ManagedEnvironmentPrivateEndpointConnectionsListCustomPager struct {
	NextLink *odata.Link `json:"nextLink"`
}
func (p *ManagedEnvironmentPrivateEndpointConnectionsListCustomPager) NextPageLink() *odata.Link

type ManagedEnvironmentPrivateEndpointConnectionsListOperationResponse 

type ManagedEnvironmentPrivateEndpointConnectionsListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]PrivateEndpointConnection
}

type PrivateEndpoint 

type PrivateEndpoint struct {
	Id *string `json:"id,omitempty"`
}

type PrivateEndpointConnection 

type PrivateEndpointConnection struct {
	Id         *string                              `json:"id,omitempty"`
	Name       *string                              `json:"name,omitempty"`
	Properties *PrivateEndpointConnectionProperties `json:"properties,omitempty"`
	SystemData *systemdata.SystemData               `json:"systemData,omitempty"`
	Type       *string                              `json:"type,omitempty"`
}

type PrivateEndpointConnectionId 

type PrivateEndpointConnectionId struct {
	SubscriptionId                string
	ResourceGroupName             string
	ManagedEnvironmentName        string
	PrivateEndpointConnectionName string
}

PrivateEndpointConnectionId is a struct representing the Resource ID for a Private Endpoint Connection

func NewPrivateEndpointConnectionID 

func NewPrivateEndpointConnectionID(subscriptionId string, resourceGroupName string, managedEnvironmentName string, privateEndpointConnectionName string) PrivateEndpointConnectionId

NewPrivateEndpointConnectionID returns a new PrivateEndpointConnectionId struct

func ParsePrivateEndpointConnectionID 

func ParsePrivateEndpointConnectionID(input string) (*PrivateEndpointConnectionId, error)

ParsePrivateEndpointConnectionID parses 'input' into a PrivateEndpointConnectionId

func ParsePrivateEndpointConnectionIDInsensitively 

func ParsePrivateEndpointConnectionIDInsensitively(input string) (*PrivateEndpointConnectionId, error)

ParsePrivateEndpointConnectionIDInsensitively parses 'input' case-insensitively into a PrivateEndpointConnectionId note: this method should only be used for API response data and not user input

func (*PrivateEndpointConnectionId) FromParseResult 

func (id *PrivateEndpointConnectionId) FromParseResult(input resourceids.ParseResult) error

func (PrivateEndpointConnectionId) ID 

func (id PrivateEndpointConnectionId) ID() string

ID returns the formatted Private Endpoint Connection ID

func (PrivateEndpointConnectionId) Segments 

func (id PrivateEndpointConnectionId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Private Endpoint Connection ID

func (PrivateEndpointConnectionId) String 

func (id PrivateEndpointConnectionId) String() string

String returns a human-readable description of this Private Endpoint Connection ID

type PrivateEndpointConnectionOperationPredicate 

type PrivateEndpointConnectionOperationPredicate struct {
	Id   *string
	Name *string
	Type *string
}

func (PrivateEndpointConnectionOperationPredicate) Matches 

func (p PrivateEndpointConnectionOperationPredicate) Matches(input PrivateEndpointConnection) bool

type PrivateEndpointConnectionProperties 

type PrivateEndpointConnectionProperties struct {
	GroupIds                          *[]string                                   `json:"groupIds,omitempty"`
	PrivateEndpoint                   *PrivateEndpoint                            `json:"privateEndpoint,omitempty"`
	PrivateLinkServiceConnectionState PrivateLinkServiceConnectionState           `json:"privateLinkServiceConnectionState"`
	ProvisioningState                 *PrivateEndpointConnectionProvisioningState `json:"provisioningState,omitempty"`
}

type PrivateEndpointConnectionProvisioningState 

type PrivateEndpointConnectionProvisioningState string
const (
	PrivateEndpointConnectionProvisioningStateCanceled  PrivateEndpointConnectionProvisioningState = "Canceled"
	PrivateEndpointConnectionProvisioningStateDeleting  PrivateEndpointConnectionProvisioningState = "Deleting"
	PrivateEndpointConnectionProvisioningStateFailed    PrivateEndpointConnectionProvisioningState = "Failed"
	PrivateEndpointConnectionProvisioningStatePending   PrivateEndpointConnectionProvisioningState = "Pending"
	PrivateEndpointConnectionProvisioningStateSucceeded PrivateEndpointConnectionProvisioningState = "Succeeded"
	PrivateEndpointConnectionProvisioningStateUpdating  PrivateEndpointConnectionProvisioningState = "Updating"
	PrivateEndpointConnectionProvisioningStateWaiting   PrivateEndpointConnectionProvisioningState = "Waiting"
)

func (*PrivateEndpointConnectionProvisioningState) UnmarshalJSON 

func (s *PrivateEndpointConnectionProvisioningState) UnmarshalJSON(bytes []byte) error

type PrivateEndpointConnectionsClient 

type PrivateEndpointConnectionsClient struct {
	Client *resourcemanager.Client
}

func NewPrivateEndpointConnectionsClientWithBaseURI 

func NewPrivateEndpointConnectionsClientWithBaseURI(sdkApi sdkEnv.Api) (*PrivateEndpointConnectionsClient, error)

func (PrivateEndpointConnectionsClient) ManagedEnvironmentPrivateEndpointConnectionsCreateOrUpdate 

func (c PrivateEndpointConnectionsClient) ManagedEnvironmentPrivateEndpointConnectionsCreateOrUpdate(ctx context.Context, id PrivateEndpointConnectionId, input PrivateEndpointConnection) (result ManagedEnvironmentPrivateEndpointConnectionsCreateOrUpdateOperationResponse, err error)

ManagedEnvironmentPrivateEndpointConnectionsCreateOrUpdate ...

func (PrivateEndpointConnectionsClient) ManagedEnvironmentPrivateEndpointConnectionsCreateOrUpdateThenPoll 

func (c PrivateEndpointConnectionsClient) ManagedEnvironmentPrivateEndpointConnectionsCreateOrUpdateThenPoll(ctx context.Context, id PrivateEndpointConnectionId, input PrivateEndpointConnection) error

ManagedEnvironmentPrivateEndpointConnectionsCreateOrUpdateThenPoll performs ManagedEnvironmentPrivateEndpointConnectionsCreateOrUpdate then polls until it's completed

func (PrivateEndpointConnectionsClient) ManagedEnvironmentPrivateEndpointConnectionsDelete 

func (c PrivateEndpointConnectionsClient) ManagedEnvironmentPrivateEndpointConnectionsDelete(ctx context.Context, id PrivateEndpointConnectionId) (result ManagedEnvironmentPrivateEndpointConnectionsDeleteOperationResponse, err error)

ManagedEnvironmentPrivateEndpointConnectionsDelete ...

func (PrivateEndpointConnectionsClient) ManagedEnvironmentPrivateEndpointConnectionsDeleteThenPoll 

func (c PrivateEndpointConnectionsClient) ManagedEnvironmentPrivateEndpointConnectionsDeleteThenPoll(ctx context.Context, id PrivateEndpointConnectionId) error

ManagedEnvironmentPrivateEndpointConnectionsDeleteThenPoll performs ManagedEnvironmentPrivateEndpointConnectionsDelete then polls until it's completed

func (PrivateEndpointConnectionsClient) ManagedEnvironmentPrivateEndpointConnectionsGet 

func (c PrivateEndpointConnectionsClient) ManagedEnvironmentPrivateEndpointConnectionsGet(ctx context.Context, id PrivateEndpointConnectionId) (result ManagedEnvironmentPrivateEndpointConnectionsGetOperationResponse, err error)

ManagedEnvironmentPrivateEndpointConnectionsGet ...

func (PrivateEndpointConnectionsClient) ManagedEnvironmentPrivateEndpointConnectionsList 

func (c PrivateEndpointConnectionsClient) ManagedEnvironmentPrivateEndpointConnectionsList(ctx context.Context, id ManagedEnvironmentId) (result ManagedEnvironmentPrivateEndpointConnectionsListOperationResponse, err error)

ManagedEnvironmentPrivateEndpointConnectionsList ...

func (PrivateEndpointConnectionsClient) ManagedEnvironmentPrivateEndpointConnectionsListComplete 

func (c PrivateEndpointConnectionsClient) ManagedEnvironmentPrivateEndpointConnectionsListComplete(ctx context.Context, id ManagedEnvironmentId) (ManagedEnvironmentPrivateEndpointConnectionsListCompleteResult, error)

ManagedEnvironmentPrivateEndpointConnectionsListComplete retrieves all the results into a single object

func (PrivateEndpointConnectionsClient) ManagedEnvironmentPrivateEndpointConnectionsListCompleteMatchingPredicate 

func (c PrivateEndpointConnectionsClient) ManagedEnvironmentPrivateEndpointConnectionsListCompleteMatchingPredicate(ctx context.Context, id ManagedEnvironmentId, predicate PrivateEndpointConnectionOperationPredicate) (result ManagedEnvironmentPrivateEndpointConnectionsListCompleteResult, err error)

ManagedEnvironmentPrivateEndpointConnectionsListCompleteMatchingPredicate retrieves all the results and then applies the predicate

type PrivateEndpointServiceConnectionStatus 

type PrivateEndpointServiceConnectionStatus string
const (
	PrivateEndpointServiceConnectionStatusApproved     PrivateEndpointServiceConnectionStatus = "Approved"
	PrivateEndpointServiceConnectionStatusDisconnected PrivateEndpointServiceConnectionStatus = "Disconnected"
	PrivateEndpointServiceConnectionStatusPending      PrivateEndpointServiceConnectionStatus = "Pending"
	PrivateEndpointServiceConnectionStatusRejected     PrivateEndpointServiceConnectionStatus = "Rejected"
)

func (*PrivateEndpointServiceConnectionStatus) UnmarshalJSON 

func (s *PrivateEndpointServiceConnectionStatus) UnmarshalJSON(bytes []byte) error

type PrivateLinkServiceConnectionState 

type PrivateLinkServiceConnectionState struct {
	ActionsRequired *string                                 `json:"actionsRequired,omitempty"`
	Description     *string                                 `json:"description,omitempty"`
	Status          *PrivateEndpointServiceConnectionStatus `json:"status,omitempty"`
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.