armcdn

package module
v2.2.0 Latest Latest
Warning

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

 Go to latest Published: Apr 15, 2024 License: MIT Imports: 15 Imported by: 0

README

Azure Content Delivery Network Module for Go

PkgGoDev

The armcdn module provides operations for working with Azure Content Delivery Network.

Source code

Getting started

Prerequisites

  • an Azure subscription
  • Go 1.18 or above (You could download and install the latest version of Go from here. It will replace the existing Go on your machine. If you want to install multiple Go versions on the same machine, you could refer this doc.)

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure Content Delivery Network module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/cdn/armcdn/v2

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Content Delivery Network. The azidentity module provides facilities for various ways of authenticating with Azure including client/secret, certificate, managed identity, and more.

cred, err := azidentity.NewDefaultAzureCredential(nil)

For more information on authentication, please see the documentation for azidentity at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azidentity.

Client Factory

Azure Content Delivery Network module consists of one or more clients. We provide a client factory which could be used to create any client in this module.

clientFactory, err := armcdn.NewClientFactory(<subscription ID>, cred, nil)

You can use ClientOptions in package github.com/Azure/azure-sdk-for-go/sdk/azcore/arm to set endpoint to connect with public and sovereign clouds as well as Azure Stack. For more information, please see the documentation for azcore at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azcore.

options := arm.ClientOptions {
    ClientOptions: azcore.ClientOptions {
        Cloud: cloud.AzureChina,
    },
}
clientFactory, err := armcdn.NewClientFactory(<subscription ID>, cred, &options)

Clients

A client groups a set of related APIs, providing access to its functionality. Create one or more clients to access the APIs you require using client factory.

client := clientFactory.NewAFDCustomDomainsClient()

Fakes

The fake package contains types used for constructing in-memory fake servers used in unit tests. This allows writing tests to cover various success/error conditions without the need for connecting to a live service.

Please see https://github.com/Azure/azure-sdk-for-go/tree/main/sdk/samples/fakes for details and examples on how to use fakes.

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the Content Delivery Network label.

Contributing

This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.microsoft.com.

When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the Microsoft Open Source Code of Conduct. For more information, see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AFDCustomDomainsClient 

type AFDCustomDomainsClient struct {
	// contains filtered or unexported fields
}

AFDCustomDomainsClient contains the methods for the AFDCustomDomains group. Don't use this type directly, use NewAFDCustomDomainsClient() instead.

func NewAFDCustomDomainsClient 

func NewAFDCustomDomainsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AFDCustomDomainsClient, error)

NewAFDCustomDomainsClient creates a new instance of AFDCustomDomainsClient with the specified values.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AFDCustomDomainsClient) BeginCreate 

func (client *AFDCustomDomainsClient) BeginCreate(ctx context.Context, resourceGroupName string, profileName string, customDomainName string, customDomain AFDDomain, options *AFDCustomDomainsClientBeginCreateOptions) (*runtime.Poller[AFDCustomDomainsClientCreateResponse], error)

BeginCreate - Creates a new domain within the specified profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • customDomainName - Name of the domain under the profile which is unique globally
  • customDomain - Domain properties
  • options - AFDCustomDomainsClientBeginCreateOptions contains the optional parameters for the AFDCustomDomainsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDCustomDomains_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAFDCustomDomainsClient().BeginCreate(ctx, "RG", "profile1", "domain1", armcdn.AFDDomain{
	Properties: &armcdn.AFDDomainProperties{
		AzureDNSZone: &armcdn.ResourceReference{
			ID: to.Ptr(""),
		},
		TLSSettings: &armcdn.AFDDomainHTTPSParameters{
			CertificateType:   to.Ptr(armcdn.AfdCertificateTypeManagedCertificate),
			MinimumTLSVersion: to.Ptr(armcdn.AfdMinimumTLSVersionTLS12),
		},
		HostName: to.Ptr("www.someDomain.net"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AFDDomain = armcdn.AFDDomain{
// 	Name: to.Ptr("domain1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/customdomains"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/customdomains/domain1"),
// 	Properties: &armcdn.AFDDomainProperties{
// 		AzureDNSZone: &armcdn.ResourceReference{
// 			ID: to.Ptr(""),
// 		},
// 		PreValidatedCustomDomainResourceID: &armcdn.ResourceReference{
// 			ID: to.Ptr(""),
// 		},
// 		ProfileName: to.Ptr("profile1"),
// 		TLSSettings: &armcdn.AFDDomainHTTPSParameters{
// 			CertificateType: to.Ptr(armcdn.AfdCertificateTypeManagedCertificate),
// 			MinimumTLSVersion: to.Ptr(armcdn.AfdMinimumTLSVersionTLS12),
// 			Secret: &armcdn.ResourceReference{
// 				ID: to.Ptr(""),
// 			},
// 		},
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 		DomainValidationState: to.Ptr(armcdn.DomainValidationStateSubmitting),
// 		HostName: to.Ptr("www.contoso.com"),
// 		ValidationProperties: &armcdn.DomainValidationProperties{
// 			ExpirationDate: to.Ptr(""),
// 			ValidationToken: to.Ptr(""),
// 		},
// 	},
// }

Output:

func (*AFDCustomDomainsClient) BeginDelete 

func (client *AFDCustomDomainsClient) BeginDelete(ctx context.Context, resourceGroupName string, profileName string, customDomainName string, options *AFDCustomDomainsClientBeginDeleteOptions) (*runtime.Poller[AFDCustomDomainsClientDeleteResponse], error)

BeginDelete - Deletes an existing AzureFrontDoor domain with the specified domain name under the specified subscription, resource group and profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • customDomainName - Name of the domain under the profile which is unique globally.
  • options - AFDCustomDomainsClientBeginDeleteOptions contains the optional parameters for the AFDCustomDomainsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDCustomDomains_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAFDCustomDomainsClient().BeginDelete(ctx, "RG", "profile1", "domain1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*AFDCustomDomainsClient) BeginRefreshValidationToken 

func (client *AFDCustomDomainsClient) BeginRefreshValidationToken(ctx context.Context, resourceGroupName string, profileName string, customDomainName string, options *AFDCustomDomainsClientBeginRefreshValidationTokenOptions) (*runtime.Poller[AFDCustomDomainsClientRefreshValidationTokenResponse], error)

BeginRefreshValidationToken - Updates the domain validation token. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • customDomainName - Name of the domain under the profile which is unique globally.
  • options - AFDCustomDomainsClientBeginRefreshValidationTokenOptions contains the optional parameters for the AFDCustomDomainsClient.BeginRefreshValidationToken method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDCustomDomains_RefreshValidationToken.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAFDCustomDomainsClient().BeginRefreshValidationToken(ctx, "RG", "profile1", "domain1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*AFDCustomDomainsClient) BeginUpdate 

func (client *AFDCustomDomainsClient) BeginUpdate(ctx context.Context, resourceGroupName string, profileName string, customDomainName string, customDomainUpdateProperties AFDDomainUpdateParameters, options *AFDCustomDomainsClientBeginUpdateOptions) (*runtime.Poller[AFDCustomDomainsClientUpdateResponse], error)

BeginUpdate - Updates an existing domain within a profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • customDomainName - Name of the domain under the profile which is unique globally
  • customDomainUpdateProperties - Domain properties
  • options - AFDCustomDomainsClientBeginUpdateOptions contains the optional parameters for the AFDCustomDomainsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDCustomDomains_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAFDCustomDomainsClient().BeginUpdate(ctx, "RG", "profile1", "domain1", armcdn.AFDDomainUpdateParameters{
	Properties: &armcdn.AFDDomainUpdatePropertiesParameters{
		AzureDNSZone: &armcdn.ResourceReference{
			ID: to.Ptr(""),
		},
		TLSSettings: &armcdn.AFDDomainHTTPSParameters{
			CertificateType:   to.Ptr(armcdn.AfdCertificateTypeCustomerCertificate),
			MinimumTLSVersion: to.Ptr(armcdn.AfdMinimumTLSVersionTLS12),
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AFDDomain = armcdn.AFDDomain{
// 	Name: to.Ptr("domain1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/customdomains"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/customdomains/domain1"),
// 	Properties: &armcdn.AFDDomainProperties{
// 		AzureDNSZone: &armcdn.ResourceReference{
// 			ID: to.Ptr(""),
// 		},
// 		PreValidatedCustomDomainResourceID: &armcdn.ResourceReference{
// 			ID: to.Ptr(""),
// 		},
// 		ProfileName: to.Ptr("profile1"),
// 		TLSSettings: &armcdn.AFDDomainHTTPSParameters{
// 			CertificateType: to.Ptr(armcdn.AfdCertificateTypeManagedCertificate),
// 			MinimumTLSVersion: to.Ptr(armcdn.AfdMinimumTLSVersionTLS12),
// 			Secret: &armcdn.ResourceReference{
// 				ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/secrets/mysecert"),
// 			},
// 		},
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 		DomainValidationState: to.Ptr(armcdn.DomainValidationStateApproved),
// 		HostName: to.Ptr("www.contoso.com"),
// 		ValidationProperties: &armcdn.DomainValidationProperties{
// 			ExpirationDate: to.Ptr("2009-06-15T13:45:43.0000000Z"),
// 			ValidationToken: to.Ptr("8c9912db-c615-4eeb-8465"),
// 		},
// 	},
// }

Output:

func (*AFDCustomDomainsClient) Get 

func (client *AFDCustomDomainsClient) Get(ctx context.Context, resourceGroupName string, profileName string, customDomainName string, options *AFDCustomDomainsClientGetOptions) (AFDCustomDomainsClientGetResponse, error)

Get - Gets an existing AzureFrontDoor domain with the specified domain name under the specified subscription, resource group and profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • customDomainName - Name of the domain under the profile which is unique globally.
  • options - AFDCustomDomainsClientGetOptions contains the optional parameters for the AFDCustomDomainsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDCustomDomains_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAFDCustomDomainsClient().Get(ctx, "RG", "profile1", "domain1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AFDDomain = armcdn.AFDDomain{
// 	Name: to.Ptr("domain1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/customdomains"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/customdomains/domain1"),
// 	Properties: &armcdn.AFDDomainProperties{
// 		AzureDNSZone: &armcdn.ResourceReference{
// 			ID: to.Ptr(""),
// 		},
// 		PreValidatedCustomDomainResourceID: &armcdn.ResourceReference{
// 			ID: to.Ptr(""),
// 		},
// 		ProfileName: to.Ptr("profile1"),
// 		TLSSettings: &armcdn.AFDDomainHTTPSParameters{
// 			CertificateType: to.Ptr(armcdn.AfdCertificateTypeManagedCertificate),
// 			MinimumTLSVersion: to.Ptr(armcdn.AfdMinimumTLSVersionTLS12),
// 			Secret: &armcdn.ResourceReference{
// 				ID: to.Ptr(""),
// 			},
// 		},
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 		DomainValidationState: to.Ptr(armcdn.DomainValidationStatePending),
// 		HostName: to.Ptr("www.contoso.com"),
// 		ValidationProperties: &armcdn.DomainValidationProperties{
// 			ExpirationDate: to.Ptr("2009-06-15T13:45:43.0000000Z"),
// 			ValidationToken: to.Ptr("8c9912db-c615-4eeb-8465"),
// 		},
// 	},
// }

Output:

func (*AFDCustomDomainsClient) NewListByProfilePager 

func (client *AFDCustomDomainsClient) NewListByProfilePager(resourceGroupName string, profileName string, options *AFDCustomDomainsClientListByProfileOptions) *runtime.Pager[AFDCustomDomainsClientListByProfileResponse]

NewListByProfilePager - Lists existing AzureFrontDoor domains.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • options - AFDCustomDomainsClientListByProfileOptions contains the optional parameters for the AFDCustomDomainsClient.NewListByProfilePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDCustomDomains_ListByProfile.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAFDCustomDomainsClient().NewListByProfilePager("RG", "profile1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.AFDDomainListResult = armcdn.AFDDomainListResult{
	// 	Value: []*armcdn.AFDDomain{
	// 		{
	// 			Name: to.Ptr("domain1"),
	// 			Type: to.Ptr("Microsoft.Cdn/profiles/customdomains"),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/customdomains/domain1"),
	// 			Properties: &armcdn.AFDDomainProperties{
	// 				AzureDNSZone: &armcdn.ResourceReference{
	// 					ID: to.Ptr(""),
	// 				},
	// 				PreValidatedCustomDomainResourceID: &armcdn.ResourceReference{
	// 					ID: to.Ptr(""),
	// 				},
	// 				ProfileName: to.Ptr("profile1"),
	// 				TLSSettings: &armcdn.AFDDomainHTTPSParameters{
	// 					CertificateType: to.Ptr(armcdn.AfdCertificateTypeManagedCertificate),
	// 					MinimumTLSVersion: to.Ptr(armcdn.AfdMinimumTLSVersionTLS12),
	// 					Secret: &armcdn.ResourceReference{
	// 						ID: to.Ptr(""),
	// 					},
	// 				},
	// 				DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
	// 				ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
	// 				DomainValidationState: to.Ptr(armcdn.DomainValidationStatePending),
	// 				HostName: to.Ptr("www.contoso.com"),
	// 				ValidationProperties: &armcdn.DomainValidationProperties{
	// 					ExpirationDate: to.Ptr("2009-06-15T13:45:43.0000000Z"),
	// 					ValidationToken: to.Ptr("8c9912db-c615-4eeb-8465"),
	// 				},
	// 			},
	// 	}},
	// }
}

Output:

type AFDCustomDomainsClientBeginCreateOptions 

type AFDCustomDomainsClientBeginCreateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AFDCustomDomainsClientBeginCreateOptions contains the optional parameters for the AFDCustomDomainsClient.BeginCreate method.

type AFDCustomDomainsClientBeginDeleteOptions 

type AFDCustomDomainsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AFDCustomDomainsClientBeginDeleteOptions contains the optional parameters for the AFDCustomDomainsClient.BeginDelete method.

type AFDCustomDomainsClientBeginRefreshValidationTokenOptions 

type AFDCustomDomainsClientBeginRefreshValidationTokenOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AFDCustomDomainsClientBeginRefreshValidationTokenOptions contains the optional parameters for the AFDCustomDomainsClient.BeginRefreshValidationToken method.

type AFDCustomDomainsClientBeginUpdateOptions 

type AFDCustomDomainsClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AFDCustomDomainsClientBeginUpdateOptions contains the optional parameters for the AFDCustomDomainsClient.BeginUpdate method.

type AFDCustomDomainsClientCreateResponse 

type AFDCustomDomainsClientCreateResponse struct {
	// Friendly domain name mapping to the endpoint hostname that the customer provides for branding purposes, e.g. www.contoso.com.
	AFDDomain
}

AFDCustomDomainsClientCreateResponse contains the response from method AFDCustomDomainsClient.BeginCreate.

type AFDCustomDomainsClientDeleteResponse 

type AFDCustomDomainsClientDeleteResponse struct {
}

AFDCustomDomainsClientDeleteResponse contains the response from method AFDCustomDomainsClient.BeginDelete.

type AFDCustomDomainsClientGetOptions 

type AFDCustomDomainsClientGetOptions struct {
}

AFDCustomDomainsClientGetOptions contains the optional parameters for the AFDCustomDomainsClient.Get method.

type AFDCustomDomainsClientGetResponse 

type AFDCustomDomainsClientGetResponse struct {
	// Friendly domain name mapping to the endpoint hostname that the customer provides for branding purposes, e.g. www.contoso.com.
	AFDDomain
}

AFDCustomDomainsClientGetResponse contains the response from method AFDCustomDomainsClient.Get.

type AFDCustomDomainsClientListByProfileOptions 

type AFDCustomDomainsClientListByProfileOptions struct {
}

AFDCustomDomainsClientListByProfileOptions contains the optional parameters for the AFDCustomDomainsClient.NewListByProfilePager method.

type AFDCustomDomainsClientListByProfileResponse 

type AFDCustomDomainsClientListByProfileResponse struct {
	// Result of the request to list domains. It contains a list of domain objects and a URL link to get the next set of results.
	AFDDomainListResult
}

AFDCustomDomainsClientListByProfileResponse contains the response from method AFDCustomDomainsClient.NewListByProfilePager.

type AFDCustomDomainsClientRefreshValidationTokenResponse 

type AFDCustomDomainsClientRefreshValidationTokenResponse struct {
}

AFDCustomDomainsClientRefreshValidationTokenResponse contains the response from method AFDCustomDomainsClient.BeginRefreshValidationToken.

type AFDCustomDomainsClientUpdateResponse 

type AFDCustomDomainsClientUpdateResponse struct {
	// Friendly domain name mapping to the endpoint hostname that the customer provides for branding purposes, e.g. www.contoso.com.
	AFDDomain
}

AFDCustomDomainsClientUpdateResponse contains the response from method AFDCustomDomainsClient.BeginUpdate.

type AFDDomain 

type AFDDomain struct {
	// The JSON object that contains the properties of the domain to create.
	Properties *AFDDomainProperties

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Read only system data
	SystemData *SystemData

	// READ-ONLY; Resource type.
	Type *string
}

AFDDomain - Friendly domain name mapping to the endpoint hostname that the customer provides for branding purposes, e.g. www.contoso.com.

func (AFDDomain) MarshalJSON 

func (a AFDDomain) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDDomain.

func (*AFDDomain) UnmarshalJSON 

func (a *AFDDomain) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDDomain.

type AFDDomainHTTPSParameters 

type AFDDomainHTTPSParameters struct {
	// REQUIRED; Defines the source of the SSL certificate.
	CertificateType *AfdCertificateType

	// TLS protocol version that will be used for Https
	MinimumTLSVersion *AfdMinimumTLSVersion

	// Resource reference to the secret. ie. subs/rg/profile/secret
	Secret *ResourceReference
}

AFDDomainHTTPSParameters - The JSON object that contains the properties to secure a domain.

func (AFDDomainHTTPSParameters) MarshalJSON 

func (a AFDDomainHTTPSParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDDomainHTTPSParameters.

func (*AFDDomainHTTPSParameters) UnmarshalJSON 

func (a *AFDDomainHTTPSParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDDomainHTTPSParameters.

type AFDDomainListResult 

type AFDDomainListResult struct {
	// URL to get the next set of domain objects if there are any.
	NextLink *string

	// READ-ONLY; List of AzureFrontDoor domains within a profile.
	Value []*AFDDomain
}

AFDDomainListResult - Result of the request to list domains. It contains a list of domain objects and a URL link to get the next set of results.

func (AFDDomainListResult) MarshalJSON 

func (a AFDDomainListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDDomainListResult.

func (*AFDDomainListResult) UnmarshalJSON 

func (a *AFDDomainListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDDomainListResult.

type AFDDomainProperties 

type AFDDomainProperties struct {
	// REQUIRED; The host name of the domain. Must be a domain name.
	HostName *string

	// Resource reference to the Azure DNS zone
	AzureDNSZone *ResourceReference

	// Key-Value pair representing migration properties for domains.
	ExtendedProperties map[string]*string

	// Resource reference to the Azure resource where custom domain ownership was prevalidated
	PreValidatedCustomDomainResourceID *ResourceReference

	// The configuration specifying how to enable HTTPS for the domain - using AzureFrontDoor managed certificate or user's own
	// certificate. If not specified, enabling ssl uses AzureFrontDoor managed
	// certificate by default.
	TLSSettings *AFDDomainHTTPSParameters

	// READ-ONLY
	DeploymentStatus *DeploymentStatus

	// READ-ONLY; Provisioning substate shows the progress of custom HTTPS enabling/disabling process step by step. DCV stands
	// for DomainControlValidation.
	DomainValidationState *DomainValidationState

	// READ-ONLY; The name of the profile which holds the domain.
	ProfileName *string

	// READ-ONLY; Provisioning status
	ProvisioningState *AfdProvisioningState

	// READ-ONLY; Values the customer needs to validate domain ownership
	ValidationProperties *DomainValidationProperties
}

AFDDomainProperties - The JSON object that contains the properties of the domain to create.

func (AFDDomainProperties) MarshalJSON 

func (a AFDDomainProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDDomainProperties.

func (*AFDDomainProperties) UnmarshalJSON 

func (a *AFDDomainProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDDomainProperties.

type AFDDomainUpdateParameters 

type AFDDomainUpdateParameters struct {
	// The JSON object that contains the properties of the domain to create.
	Properties *AFDDomainUpdatePropertiesParameters
}

AFDDomainUpdateParameters - The domain JSON object required for domain creation or update.

func (AFDDomainUpdateParameters) MarshalJSON 

func (a AFDDomainUpdateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDDomainUpdateParameters.

func (*AFDDomainUpdateParameters) UnmarshalJSON 

func (a *AFDDomainUpdateParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDDomainUpdateParameters.

type AFDDomainUpdatePropertiesParameters 

type AFDDomainUpdatePropertiesParameters struct {
	// Resource reference to the Azure DNS zone
	AzureDNSZone *ResourceReference

	// Resource reference to the Azure resource where custom domain ownership was prevalidated
	PreValidatedCustomDomainResourceID *ResourceReference

	// The configuration specifying how to enable HTTPS for the domain - using AzureFrontDoor managed certificate or user's own
	// certificate. If not specified, enabling ssl uses AzureFrontDoor managed
	// certificate by default.
	TLSSettings *AFDDomainHTTPSParameters

	// READ-ONLY; The name of the profile which holds the domain.
	ProfileName *string
}

AFDDomainUpdatePropertiesParameters - The JSON object that contains the properties of the domain to create.

func (AFDDomainUpdatePropertiesParameters) MarshalJSON 

func (a AFDDomainUpdatePropertiesParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDDomainUpdatePropertiesParameters.

func (*AFDDomainUpdatePropertiesParameters) UnmarshalJSON 

func (a *AFDDomainUpdatePropertiesParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDDomainUpdatePropertiesParameters.

type AFDEndpoint 

type AFDEndpoint struct {
	// REQUIRED; Resource location.
	Location *string

	// The JSON object that contains the properties required to create an endpoint.
	Properties *AFDEndpointProperties

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Read only system data
	SystemData *SystemData

	// READ-ONLY; Resource type.
	Type *string
}

AFDEndpoint - Azure Front Door endpoint is the entity within a Azure Front Door profile containing configuration information such as origin, protocol, content caching and delivery behavior. The AzureFrontDoor endpoint uses the URL format .azureedge.net.

func (AFDEndpoint) MarshalJSON 

func (a AFDEndpoint) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDEndpoint.

func (*AFDEndpoint) UnmarshalJSON 

func (a *AFDEndpoint) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDEndpoint.

type AFDEndpointListResult 

type AFDEndpointListResult struct {
	// URL to get the next set of endpoint objects if there is any.
	NextLink *string

	// READ-ONLY; List of AzureFrontDoor endpoints within a profile
	Value []*AFDEndpoint
}

AFDEndpointListResult - Result of the request to list endpoints. It contains a list of endpoint objects and a URL link to get the next set of results.

func (AFDEndpointListResult) MarshalJSON 

func (a AFDEndpointListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDEndpointListResult.

func (*AFDEndpointListResult) UnmarshalJSON 

func (a *AFDEndpointListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDEndpointListResult.

type AFDEndpointProperties 

type AFDEndpointProperties struct {
	// Indicates the endpoint name reuse scope. The default value is TenantReuse.
	AutoGeneratedDomainNameLabelScope *AutoGeneratedDomainNameLabelScope

	// Whether to enable use of this rule. Permitted values are 'Enabled' or 'Disabled'
	EnabledState *EnabledState

	// READ-ONLY
	DeploymentStatus *DeploymentStatus

	// READ-ONLY; The host name of the endpoint structured as {endpointName}.{DNSZone}, e.g. contoso.azureedge.net
	HostName *string

	// READ-ONLY; The name of the profile which holds the endpoint.
	ProfileName *string

	// READ-ONLY; Provisioning status
	ProvisioningState *AfdProvisioningState
}

AFDEndpointProperties - The JSON object that contains the properties required to create an endpoint.

func (AFDEndpointProperties) MarshalJSON 

func (a AFDEndpointProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDEndpointProperties.

func (*AFDEndpointProperties) UnmarshalJSON 

func (a *AFDEndpointProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDEndpointProperties.

type AFDEndpointPropertiesUpdateParameters 

type AFDEndpointPropertiesUpdateParameters struct {
	// Whether to enable use of this rule. Permitted values are 'Enabled' or 'Disabled'
	EnabledState *EnabledState

	// READ-ONLY; The name of the profile which holds the endpoint.
	ProfileName *string
}

AFDEndpointPropertiesUpdateParameters - The JSON object containing endpoint update parameters.

func (AFDEndpointPropertiesUpdateParameters) MarshalJSON 

func (a AFDEndpointPropertiesUpdateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDEndpointPropertiesUpdateParameters.

func (*AFDEndpointPropertiesUpdateParameters) UnmarshalJSON 

func (a *AFDEndpointPropertiesUpdateParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDEndpointPropertiesUpdateParameters.

type AFDEndpointProtocols 

type AFDEndpointProtocols string

AFDEndpointProtocols - Supported protocols for the customer's endpoint. 

const (
	AFDEndpointProtocolsHTTP  AFDEndpointProtocols = "Http"
	AFDEndpointProtocolsHTTPS AFDEndpointProtocols = "Https"
)

func PossibleAFDEndpointProtocolsValues 

func PossibleAFDEndpointProtocolsValues() []AFDEndpointProtocols

PossibleAFDEndpointProtocolsValues returns the possible values for the AFDEndpointProtocols const type.

type AFDEndpointUpdateParameters 

type AFDEndpointUpdateParameters struct {
	// The JSON object containing endpoint update parameters.
	Properties *AFDEndpointPropertiesUpdateParameters

	// Endpoint tags.
	Tags map[string]*string
}

AFDEndpointUpdateParameters - Properties required to create or update an endpoint.

func (AFDEndpointUpdateParameters) MarshalJSON 

func (a AFDEndpointUpdateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDEndpointUpdateParameters.

func (*AFDEndpointUpdateParameters) UnmarshalJSON 

func (a *AFDEndpointUpdateParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDEndpointUpdateParameters.

type AFDEndpointsClient 

type AFDEndpointsClient struct {
	// contains filtered or unexported fields
}

AFDEndpointsClient contains the methods for the AFDEndpoints group. Don't use this type directly, use NewAFDEndpointsClient() instead.

func NewAFDEndpointsClient 

func NewAFDEndpointsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AFDEndpointsClient, error)

NewAFDEndpointsClient creates a new instance of AFDEndpointsClient with the specified values.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AFDEndpointsClient) BeginCreate 

func (client *AFDEndpointsClient) BeginCreate(ctx context.Context, resourceGroupName string, profileName string, endpointName string, endpoint AFDEndpoint, options *AFDEndpointsClientBeginCreateOptions) (*runtime.Poller[AFDEndpointsClientCreateResponse], error)

BeginCreate - Creates a new AzureFrontDoor endpoint with the specified endpoint name under the specified subscription, resource group and profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • endpoint - Endpoint properties
  • options - AFDEndpointsClientBeginCreateOptions contains the optional parameters for the AFDEndpointsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDEndpoints_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAFDEndpointsClient().BeginCreate(ctx, "RG", "profile1", "endpoint1", armcdn.AFDEndpoint{
	Location: to.Ptr("global"),
	Tags:     map[string]*string{},
	Properties: &armcdn.AFDEndpointProperties{
		EnabledState:                      to.Ptr(armcdn.EnabledStateEnabled),
		AutoGeneratedDomainNameLabelScope: to.Ptr(armcdn.AutoGeneratedDomainNameLabelScopeTenantReuse),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AFDEndpoint = armcdn.AFDEndpoint{
// 	Name: to.Ptr("endpoint1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/afdendpoints"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/afdendpoints/endpoint1"),
// 	Location: to.Ptr("global"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armcdn.AFDEndpointProperties{
// 		EnabledState: to.Ptr(armcdn.EnabledStateEnabled),
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 		AutoGeneratedDomainNameLabelScope: to.Ptr(armcdn.AutoGeneratedDomainNameLabelScopeTenantReuse),
// 		HostName: to.Ptr("endpoint1-abcdefghijklmnop.z01.azurefd.net"),
// 	},
// }

Output:

func (*AFDEndpointsClient) BeginDelete 

func (client *AFDEndpointsClient) BeginDelete(ctx context.Context, resourceGroupName string, profileName string, endpointName string, options *AFDEndpointsClientBeginDeleteOptions) (*runtime.Poller[AFDEndpointsClientDeleteResponse], error)

BeginDelete - Deletes an existing AzureFrontDoor endpoint with the specified endpoint name under the specified subscription, resource group and profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • options - AFDEndpointsClientBeginDeleteOptions contains the optional parameters for the AFDEndpointsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDEndpoints_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAFDEndpointsClient().BeginDelete(ctx, "RG", "profile1", "endpoint1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*AFDEndpointsClient) BeginPurgeContent 

func (client *AFDEndpointsClient) BeginPurgeContent(ctx context.Context, resourceGroupName string, profileName string, endpointName string, contents AfdPurgeParameters, options *AFDEndpointsClientBeginPurgeContentOptions) (*runtime.Poller[AFDEndpointsClientPurgeContentResponse], error)

BeginPurgeContent - Removes a content from AzureFrontDoor. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • contents - The list of paths to the content and the list of linked domains to be purged. Path can be a full URL, e.g. '/pictures/city.png' which removes a single file, or a directory with a wildcard, e.g. '/pictures/*' which removes all folders and files in the directory.
  • options - AFDEndpointsClientBeginPurgeContentOptions contains the optional parameters for the AFDEndpointsClient.BeginPurgeContent method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDEndpoints_PurgeContent.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAFDEndpointsClient().BeginPurgeContent(ctx, "RG", "profile1", "endpoint1", armcdn.AfdPurgeParameters{
	ContentPaths: []*string{
		to.Ptr("/folder1")},
	Domains: []*string{
		to.Ptr("endpoint1-abcdefghijklmnop.z01.azurefd.net")},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*AFDEndpointsClient) BeginUpdate 

func (client *AFDEndpointsClient) BeginUpdate(ctx context.Context, resourceGroupName string, profileName string, endpointName string, endpointUpdateProperties AFDEndpointUpdateParameters, options *AFDEndpointsClientBeginUpdateOptions) (*runtime.Poller[AFDEndpointsClientUpdateResponse], error)

BeginUpdate - Updates an existing AzureFrontDoor endpoint with the specified endpoint name under the specified subscription, resource group and profile. Only tags can be updated after creating an endpoint. To update origins, use the Update Origin operation. To update origin groups, use the Update Origin group operation. To update domains, use the Update Custom Domain operation. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • endpointUpdateProperties - Endpoint update properties
  • options - AFDEndpointsClientBeginUpdateOptions contains the optional parameters for the AFDEndpointsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDEndpoints_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAFDEndpointsClient().BeginUpdate(ctx, "RG", "profile1", "endpoint1", armcdn.AFDEndpointUpdateParameters{
	Properties: &armcdn.AFDEndpointPropertiesUpdateParameters{
		EnabledState: to.Ptr(armcdn.EnabledStateEnabled),
	},
	Tags: map[string]*string{},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AFDEndpoint = armcdn.AFDEndpoint{
// 	Name: to.Ptr("endpoint1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/afdendpoints"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/afdendpoints/endpoint1"),
// 	Location: to.Ptr("global"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armcdn.AFDEndpointProperties{
// 		EnabledState: to.Ptr(armcdn.EnabledStateEnabled),
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 		AutoGeneratedDomainNameLabelScope: to.Ptr(armcdn.AutoGeneratedDomainNameLabelScopeTenantReuse),
// 		HostName: to.Ptr("endpoint1-ezh7ddcmguaeajfu.z01.azureedge.net"),
// 	},
// }

Output:

func (*AFDEndpointsClient) Get 

func (client *AFDEndpointsClient) Get(ctx context.Context, resourceGroupName string, profileName string, endpointName string, options *AFDEndpointsClientGetOptions) (AFDEndpointsClientGetResponse, error)

Get - Gets an existing AzureFrontDoor endpoint with the specified endpoint name under the specified subscription, resource group and profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • options - AFDEndpointsClientGetOptions contains the optional parameters for the AFDEndpointsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDEndpoints_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAFDEndpointsClient().Get(ctx, "RG", "profile1", "endpoint1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AFDEndpoint = armcdn.AFDEndpoint{
// 	Name: to.Ptr("endpoint1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/afdendpoints"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/afdendpoints/endpoint1"),
// 	Location: to.Ptr("global"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armcdn.AFDEndpointProperties{
// 		EnabledState: to.Ptr(armcdn.EnabledStateEnabled),
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 		AutoGeneratedDomainNameLabelScope: to.Ptr(armcdn.AutoGeneratedDomainNameLabelScopeTenantReuse),
// 		HostName: to.Ptr("endpoint1-abcdefghijklmnop.z01.azurefd.net"),
// 	},
// }

Output:

func (*AFDEndpointsClient) NewListByProfilePager 

func (client *AFDEndpointsClient) NewListByProfilePager(resourceGroupName string, profileName string, options *AFDEndpointsClientListByProfileOptions) *runtime.Pager[AFDEndpointsClientListByProfileResponse]

NewListByProfilePager - Lists existing AzureFrontDoor endpoints.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • options - AFDEndpointsClientListByProfileOptions contains the optional parameters for the AFDEndpointsClient.NewListByProfilePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDEndpoints_ListByProfile.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAFDEndpointsClient().NewListByProfilePager("RG", "profile1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.AFDEndpointListResult = armcdn.AFDEndpointListResult{
	// 	Value: []*armcdn.AFDEndpoint{
	// 		{
	// 			Name: to.Ptr("endpoint1"),
	// 			Type: to.Ptr("Microsoft.Cdn/profiles/afdendpoints"),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/afdendpoints/endpoint1"),
	// 			Location: to.Ptr("global"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Properties: &armcdn.AFDEndpointProperties{
	// 				EnabledState: to.Ptr(armcdn.EnabledStateEnabled),
	// 				DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
	// 				ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
	// 				AutoGeneratedDomainNameLabelScope: to.Ptr(armcdn.AutoGeneratedDomainNameLabelScopeTenantReuse),
	// 				HostName: to.Ptr("endpoint1-abcdefghijklmnop.z01.azurefd.net"),
	// 			},
	// 	}},
	// }
}

Output:

func (*AFDEndpointsClient) NewListResourceUsagePager 

func (client *AFDEndpointsClient) NewListResourceUsagePager(resourceGroupName string, profileName string, endpointName string, options *AFDEndpointsClientListResourceUsageOptions) *runtime.Pager[AFDEndpointsClientListResourceUsageResponse]

NewListResourceUsagePager - Checks the quota and actual usage of endpoints under the given Azure Front Door profile.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • options - AFDEndpointsClientListResourceUsageOptions contains the optional parameters for the AFDEndpointsClient.NewListResourceUsagePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDEndpoints_ListResourceUsage.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAFDEndpointsClient().NewListResourceUsagePager("RG", "profile1", "endpoint1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.UsagesListResult = armcdn.UsagesListResult{
	// 	Value: []*armcdn.Usage{
	// 		{
	// 			Name: &armcdn.UsageName{
	// 				LocalizedValue: to.Ptr("route"),
	// 				Value: to.Ptr("route"),
	// 			},
	// 			CurrentValue: to.Ptr[int64](0),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/afdendpoints/endpoint1/routes/route1"),
	// 			Limit: to.Ptr[int64](25),
	// 			Unit: to.Ptr(armcdn.UsageUnitCount),
	// 	}},
	// }
}

Output:

func (*AFDEndpointsClient) ValidateCustomDomain 

func (client *AFDEndpointsClient) ValidateCustomDomain(ctx context.Context, resourceGroupName string, profileName string, endpointName string, customDomainProperties ValidateCustomDomainInput, options *AFDEndpointsClientValidateCustomDomainOptions) (AFDEndpointsClientValidateCustomDomainResponse, error)

ValidateCustomDomain - Validates the custom domain mapping to ensure it maps to the correct Azure Front Door endpoint in DNS. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • customDomainProperties - Custom domain to be validated.
  • options - AFDEndpointsClientValidateCustomDomainOptions contains the optional parameters for the AFDEndpointsClient.ValidateCustomDomain method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDEndpoints_ValidateCustomDomain.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAFDEndpointsClient().ValidateCustomDomain(ctx, "RG", "profile1", "endpoint1", armcdn.ValidateCustomDomainInput{
	HostName: to.Ptr("www.someDomain.com"),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ValidateCustomDomainOutput = armcdn.ValidateCustomDomainOutput{
// 	CustomDomainValidated: to.Ptr(true),
// }

Output:

type AFDEndpointsClientBeginCreateOptions 

type AFDEndpointsClientBeginCreateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AFDEndpointsClientBeginCreateOptions contains the optional parameters for the AFDEndpointsClient.BeginCreate method.

type AFDEndpointsClientBeginDeleteOptions 

type AFDEndpointsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AFDEndpointsClientBeginDeleteOptions contains the optional parameters for the AFDEndpointsClient.BeginDelete method.

type AFDEndpointsClientBeginPurgeContentOptions 

type AFDEndpointsClientBeginPurgeContentOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AFDEndpointsClientBeginPurgeContentOptions contains the optional parameters for the AFDEndpointsClient.BeginPurgeContent method.

type AFDEndpointsClientBeginUpdateOptions 

type AFDEndpointsClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AFDEndpointsClientBeginUpdateOptions contains the optional parameters for the AFDEndpointsClient.BeginUpdate method.

type AFDEndpointsClientCreateResponse 

type AFDEndpointsClientCreateResponse struct {
	// Azure Front Door endpoint is the entity within a Azure Front Door profile containing configuration information such as
	// origin, protocol, content caching and delivery behavior. The AzureFrontDoor endpoint uses the URL format <endpointname>.azureedge.net.
	AFDEndpoint
}

AFDEndpointsClientCreateResponse contains the response from method AFDEndpointsClient.BeginCreate.

type AFDEndpointsClientDeleteResponse 

type AFDEndpointsClientDeleteResponse struct {
}

AFDEndpointsClientDeleteResponse contains the response from method AFDEndpointsClient.BeginDelete.

type AFDEndpointsClientGetOptions 

type AFDEndpointsClientGetOptions struct {
}

AFDEndpointsClientGetOptions contains the optional parameters for the AFDEndpointsClient.Get method.

type AFDEndpointsClientGetResponse 

type AFDEndpointsClientGetResponse struct {
	// Azure Front Door endpoint is the entity within a Azure Front Door profile containing configuration information such as
	// origin, protocol, content caching and delivery behavior. The AzureFrontDoor endpoint uses the URL format <endpointname>.azureedge.net.
	AFDEndpoint
}

AFDEndpointsClientGetResponse contains the response from method AFDEndpointsClient.Get.

type AFDEndpointsClientListByProfileOptions 

type AFDEndpointsClientListByProfileOptions struct {
}

AFDEndpointsClientListByProfileOptions contains the optional parameters for the AFDEndpointsClient.NewListByProfilePager method.

type AFDEndpointsClientListByProfileResponse 

type AFDEndpointsClientListByProfileResponse struct {
	// Result of the request to list endpoints. It contains a list of endpoint objects and a URL link to get the next set of results.
	AFDEndpointListResult
}

AFDEndpointsClientListByProfileResponse contains the response from method AFDEndpointsClient.NewListByProfilePager.

type AFDEndpointsClientListResourceUsageOptions 

type AFDEndpointsClientListResourceUsageOptions struct {
}

AFDEndpointsClientListResourceUsageOptions contains the optional parameters for the AFDEndpointsClient.NewListResourceUsagePager method.

type AFDEndpointsClientListResourceUsageResponse 

type AFDEndpointsClientListResourceUsageResponse struct {
	// The list usages operation response.
	UsagesListResult
}

AFDEndpointsClientListResourceUsageResponse contains the response from method AFDEndpointsClient.NewListResourceUsagePager.

type AFDEndpointsClientPurgeContentResponse 

type AFDEndpointsClientPurgeContentResponse struct {
}

AFDEndpointsClientPurgeContentResponse contains the response from method AFDEndpointsClient.BeginPurgeContent.

type AFDEndpointsClientUpdateResponse 

type AFDEndpointsClientUpdateResponse struct {
	// Azure Front Door endpoint is the entity within a Azure Front Door profile containing configuration information such as
	// origin, protocol, content caching and delivery behavior. The AzureFrontDoor endpoint uses the URL format <endpointname>.azureedge.net.
	AFDEndpoint
}

AFDEndpointsClientUpdateResponse contains the response from method AFDEndpointsClient.BeginUpdate.

type AFDEndpointsClientValidateCustomDomainOptions 

type AFDEndpointsClientValidateCustomDomainOptions struct {
}

AFDEndpointsClientValidateCustomDomainOptions contains the optional parameters for the AFDEndpointsClient.ValidateCustomDomain method.

type AFDEndpointsClientValidateCustomDomainResponse 

type AFDEndpointsClientValidateCustomDomainResponse struct {
	// Output of custom domain validation.
	ValidateCustomDomainOutput
}

AFDEndpointsClientValidateCustomDomainResponse contains the response from method AFDEndpointsClient.ValidateCustomDomain.

type AFDOrigin 

type AFDOrigin struct {
	// The JSON object that contains the properties of the origin.
	Properties *AFDOriginProperties

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Read only system data
	SystemData *SystemData

	// READ-ONLY; Resource type.
	Type *string
}

AFDOrigin - Azure Front Door origin is the source of the content being delivered via Azure Front Door. When the edge nodes represented by an endpoint do not have the requested content cached, they attempt to fetch it from one or more of the configured origins.

func (AFDOrigin) MarshalJSON 

func (a AFDOrigin) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDOrigin.

func (*AFDOrigin) UnmarshalJSON 

func (a *AFDOrigin) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDOrigin.

type AFDOriginGroup 

type AFDOriginGroup struct {
	// The JSON object that contains the properties of the origin group.
	Properties *AFDOriginGroupProperties

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Read only system data
	SystemData *SystemData

	// READ-ONLY; Resource type.
	Type *string
}

AFDOriginGroup - AFDOrigin group comprising of origins is used for load balancing to origins when the content cannot be served from Azure Front Door.

func (AFDOriginGroup) MarshalJSON 

func (a AFDOriginGroup) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDOriginGroup.

func (*AFDOriginGroup) UnmarshalJSON 

func (a *AFDOriginGroup) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDOriginGroup.

type AFDOriginGroupListResult 

type AFDOriginGroupListResult struct {
	// URL to get the next set of origin objects if there are any.
	NextLink *string

	// READ-ONLY; List of Azure Front Door origin groups within an Azure Front Door endpoint
	Value []*AFDOriginGroup
}

AFDOriginGroupListResult - Result of the request to list origin groups. It contains a list of origin groups objects and a URL link to get the next set of results.

func (AFDOriginGroupListResult) MarshalJSON 

func (a AFDOriginGroupListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDOriginGroupListResult.

func (*AFDOriginGroupListResult) UnmarshalJSON 

func (a *AFDOriginGroupListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDOriginGroupListResult.

type AFDOriginGroupProperties 

type AFDOriginGroupProperties struct {
	// Health probe settings to the origin that is used to determine the health of the origin.
	HealthProbeSettings *HealthProbeParameters

	// Load balancing settings for a backend pool
	LoadBalancingSettings *LoadBalancingSettingsParameters

	// Whether to allow session affinity on this host. Valid options are 'Enabled' or 'Disabled'
	SessionAffinityState *EnabledState

	// Time in minutes to shift the traffic to the endpoint gradually when an unhealthy endpoint comes healthy or a new endpoint
	// is added. Default is 10 mins. This property is currently not supported.
	TrafficRestorationTimeToHealedOrNewEndpointsInMinutes *int32

	// READ-ONLY
	DeploymentStatus *DeploymentStatus

	// READ-ONLY; The name of the profile which holds the origin group.
	ProfileName *string

	// READ-ONLY; Provisioning status
	ProvisioningState *AfdProvisioningState
}

AFDOriginGroupProperties - The JSON object that contains the properties of the origin group.

func (AFDOriginGroupProperties) MarshalJSON 

func (a AFDOriginGroupProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDOriginGroupProperties.

func (*AFDOriginGroupProperties) UnmarshalJSON 

func (a *AFDOriginGroupProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDOriginGroupProperties.

type AFDOriginGroupUpdateParameters 

type AFDOriginGroupUpdateParameters struct {
	// The JSON object that contains the properties of the origin group.
	Properties *AFDOriginGroupUpdatePropertiesParameters
}

AFDOriginGroupUpdateParameters - AFDOrigin group properties needed for origin group creation or update.

func (AFDOriginGroupUpdateParameters) MarshalJSON 

func (a AFDOriginGroupUpdateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDOriginGroupUpdateParameters.

func (*AFDOriginGroupUpdateParameters) UnmarshalJSON 

func (a *AFDOriginGroupUpdateParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDOriginGroupUpdateParameters.

type AFDOriginGroupUpdatePropertiesParameters 

type AFDOriginGroupUpdatePropertiesParameters struct {
	// Health probe settings to the origin that is used to determine the health of the origin.
	HealthProbeSettings *HealthProbeParameters

	// Load balancing settings for a backend pool
	LoadBalancingSettings *LoadBalancingSettingsParameters

	// Whether to allow session affinity on this host. Valid options are 'Enabled' or 'Disabled'
	SessionAffinityState *EnabledState

	// Time in minutes to shift the traffic to the endpoint gradually when an unhealthy endpoint comes healthy or a new endpoint
	// is added. Default is 10 mins. This property is currently not supported.
	TrafficRestorationTimeToHealedOrNewEndpointsInMinutes *int32

	// READ-ONLY; The name of the profile which holds the origin group.
	ProfileName *string
}

AFDOriginGroupUpdatePropertiesParameters - The JSON object that contains the properties of the origin group.

func (AFDOriginGroupUpdatePropertiesParameters) MarshalJSON 

func (a AFDOriginGroupUpdatePropertiesParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDOriginGroupUpdatePropertiesParameters.

func (*AFDOriginGroupUpdatePropertiesParameters) UnmarshalJSON 

func (a *AFDOriginGroupUpdatePropertiesParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDOriginGroupUpdatePropertiesParameters.

type AFDOriginGroupsClient 

type AFDOriginGroupsClient struct {
	// contains filtered or unexported fields
}

AFDOriginGroupsClient contains the methods for the AFDOriginGroups group. Don't use this type directly, use NewAFDOriginGroupsClient() instead.

func NewAFDOriginGroupsClient 

func NewAFDOriginGroupsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AFDOriginGroupsClient, error)

NewAFDOriginGroupsClient creates a new instance of AFDOriginGroupsClient with the specified values.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AFDOriginGroupsClient) BeginCreate 

func (client *AFDOriginGroupsClient) BeginCreate(ctx context.Context, resourceGroupName string, profileName string, originGroupName string, originGroup AFDOriginGroup, options *AFDOriginGroupsClientBeginCreateOptions) (*runtime.Poller[AFDOriginGroupsClientCreateResponse], error)

BeginCreate - Creates a new origin group within the specified profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • originGroupName - Name of the origin group which is unique within the endpoint.
  • originGroup - Origin group properties
  • options - AFDOriginGroupsClientBeginCreateOptions contains the optional parameters for the AFDOriginGroupsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDOriginGroups_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAFDOriginGroupsClient().BeginCreate(ctx, "RG", "profile1", "origingroup1", armcdn.AFDOriginGroup{
	Properties: &armcdn.AFDOriginGroupProperties{
		HealthProbeSettings: &armcdn.HealthProbeParameters{
			ProbeIntervalInSeconds: to.Ptr[int32](10),
			ProbePath:              to.Ptr("/path2"),
			ProbeProtocol:          to.Ptr(armcdn.ProbeProtocolNotSet),
			ProbeRequestType:       to.Ptr(armcdn.HealthProbeRequestTypeNotSet),
		},
		LoadBalancingSettings: &armcdn.LoadBalancingSettingsParameters{
			AdditionalLatencyInMilliseconds: to.Ptr[int32](1000),
			SampleSize:                      to.Ptr[int32](3),
			SuccessfulSamplesRequired:       to.Ptr[int32](3),
		},
		TrafficRestorationTimeToHealedOrNewEndpointsInMinutes: to.Ptr[int32](5),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AFDOriginGroup = armcdn.AFDOriginGroup{
// 	Name: to.Ptr("origingroup1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/origingroups"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/origingroups/origingroup1"),
// 	Properties: &armcdn.AFDOriginGroupProperties{
// 		HealthProbeSettings: &armcdn.HealthProbeParameters{
// 			ProbeIntervalInSeconds: to.Ptr[int32](10),
// 			ProbePath: to.Ptr("/path1"),
// 			ProbeProtocol: to.Ptr(armcdn.ProbeProtocolHTTP),
// 			ProbeRequestType: to.Ptr(armcdn.HealthProbeRequestTypeHEAD),
// 		},
// 		LoadBalancingSettings: &armcdn.LoadBalancingSettingsParameters{
// 			AdditionalLatencyInMilliseconds: to.Ptr[int32](1000),
// 			SampleSize: to.Ptr[int32](3),
// 			SuccessfulSamplesRequired: to.Ptr[int32](3),
// 		},
// 		TrafficRestorationTimeToHealedOrNewEndpointsInMinutes: to.Ptr[int32](5),
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 	},
// }

Output:

func (*AFDOriginGroupsClient) BeginDelete 

func (client *AFDOriginGroupsClient) BeginDelete(ctx context.Context, resourceGroupName string, profileName string, originGroupName string, options *AFDOriginGroupsClientBeginDeleteOptions) (*runtime.Poller[AFDOriginGroupsClientDeleteResponse], error)

BeginDelete - Deletes an existing origin group within a profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • originGroupName - Name of the origin group which is unique within the profile.
  • options - AFDOriginGroupsClientBeginDeleteOptions contains the optional parameters for the AFDOriginGroupsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDOriginGroups_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAFDOriginGroupsClient().BeginDelete(ctx, "RG", "profile1", "origingroup1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*AFDOriginGroupsClient) BeginUpdate 

func (client *AFDOriginGroupsClient) BeginUpdate(ctx context.Context, resourceGroupName string, profileName string, originGroupName string, originGroupUpdateProperties AFDOriginGroupUpdateParameters, options *AFDOriginGroupsClientBeginUpdateOptions) (*runtime.Poller[AFDOriginGroupsClientUpdateResponse], error)

BeginUpdate - Updates an existing origin group within a profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • originGroupName - Name of the origin group which is unique within the profile.
  • originGroupUpdateProperties - Origin group properties
  • options - AFDOriginGroupsClientBeginUpdateOptions contains the optional parameters for the AFDOriginGroupsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDOriginGroups_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAFDOriginGroupsClient().BeginUpdate(ctx, "RG", "profile1", "origingroup1", armcdn.AFDOriginGroupUpdateParameters{
	Properties: &armcdn.AFDOriginGroupUpdatePropertiesParameters{
		HealthProbeSettings: &armcdn.HealthProbeParameters{
			ProbeIntervalInSeconds: to.Ptr[int32](10),
			ProbePath:              to.Ptr("/path2"),
			ProbeProtocol:          to.Ptr(armcdn.ProbeProtocolNotSet),
			ProbeRequestType:       to.Ptr(armcdn.HealthProbeRequestTypeNotSet),
		},
		LoadBalancingSettings: &armcdn.LoadBalancingSettingsParameters{
			AdditionalLatencyInMilliseconds: to.Ptr[int32](1000),
			SampleSize:                      to.Ptr[int32](3),
			SuccessfulSamplesRequired:       to.Ptr[int32](3),
		},
		TrafficRestorationTimeToHealedOrNewEndpointsInMinutes: to.Ptr[int32](5),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AFDOriginGroup = armcdn.AFDOriginGroup{
// 	Name: to.Ptr("origingroup1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/origingroups"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/origingroups/origingroup1"),
// 	Properties: &armcdn.AFDOriginGroupProperties{
// 		HealthProbeSettings: &armcdn.HealthProbeParameters{
// 			ProbeIntervalInSeconds: to.Ptr[int32](10),
// 			ProbePath: to.Ptr("/path1"),
// 			ProbeProtocol: to.Ptr(armcdn.ProbeProtocolHTTP),
// 			ProbeRequestType: to.Ptr(armcdn.HealthProbeRequestTypeHEAD),
// 		},
// 		LoadBalancingSettings: &armcdn.LoadBalancingSettingsParameters{
// 			AdditionalLatencyInMilliseconds: to.Ptr[int32](1000),
// 			SampleSize: to.Ptr[int32](3),
// 			SuccessfulSamplesRequired: to.Ptr[int32](3),
// 		},
// 		TrafficRestorationTimeToHealedOrNewEndpointsInMinutes: to.Ptr[int32](5),
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 	},
// }

Output:

func (*AFDOriginGroupsClient) Get 

func (client *AFDOriginGroupsClient) Get(ctx context.Context, resourceGroupName string, profileName string, originGroupName string, options *AFDOriginGroupsClientGetOptions) (AFDOriginGroupsClientGetResponse, error)

Get - Gets an existing origin group within a profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • originGroupName - Name of the origin group which is unique within the endpoint.
  • options - AFDOriginGroupsClientGetOptions contains the optional parameters for the AFDOriginGroupsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDOriginGroups_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAFDOriginGroupsClient().Get(ctx, "RG", "profile1", "origingroup1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AFDOriginGroup = armcdn.AFDOriginGroup{
// 	Name: to.Ptr("origingroup1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/origingroups"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/origingroups/origingroup1"),
// 	Properties: &armcdn.AFDOriginGroupProperties{
// 		HealthProbeSettings: &armcdn.HealthProbeParameters{
// 			ProbeIntervalInSeconds: to.Ptr[int32](10),
// 			ProbePath: to.Ptr("/path1"),
// 			ProbeProtocol: to.Ptr(armcdn.ProbeProtocolHTTP),
// 			ProbeRequestType: to.Ptr(armcdn.HealthProbeRequestTypeHEAD),
// 		},
// 		LoadBalancingSettings: &armcdn.LoadBalancingSettingsParameters{
// 			AdditionalLatencyInMilliseconds: to.Ptr[int32](1000),
// 			SampleSize: to.Ptr[int32](3),
// 			SuccessfulSamplesRequired: to.Ptr[int32](3),
// 		},
// 		TrafficRestorationTimeToHealedOrNewEndpointsInMinutes: to.Ptr[int32](5),
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 	},
// }

Output:

func (*AFDOriginGroupsClient) NewListByProfilePager 

func (client *AFDOriginGroupsClient) NewListByProfilePager(resourceGroupName string, profileName string, options *AFDOriginGroupsClientListByProfileOptions) *runtime.Pager[AFDOriginGroupsClientListByProfileResponse]

NewListByProfilePager - Lists all of the existing origin groups within a profile.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • options - AFDOriginGroupsClientListByProfileOptions contains the optional parameters for the AFDOriginGroupsClient.NewListByProfilePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDOriginGroups_ListByProfile.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAFDOriginGroupsClient().NewListByProfilePager("RG", "profile1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.AFDOriginGroupListResult = armcdn.AFDOriginGroupListResult{
	// 	Value: []*armcdn.AFDOriginGroup{
	// 		{
	// 			Name: to.Ptr("origingroup1"),
	// 			Type: to.Ptr("Microsoft.Cdn/profiles/origingroups"),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/origingroups/origingroup1"),
	// 			Properties: &armcdn.AFDOriginGroupProperties{
	// 				HealthProbeSettings: &armcdn.HealthProbeParameters{
	// 					ProbeIntervalInSeconds: to.Ptr[int32](10),
	// 					ProbePath: to.Ptr("/path1"),
	// 					ProbeProtocol: to.Ptr(armcdn.ProbeProtocolHTTP),
	// 					ProbeRequestType: to.Ptr(armcdn.HealthProbeRequestTypeHEAD),
	// 				},
	// 				LoadBalancingSettings: &armcdn.LoadBalancingSettingsParameters{
	// 					AdditionalLatencyInMilliseconds: to.Ptr[int32](1000),
	// 					SampleSize: to.Ptr[int32](3),
	// 					SuccessfulSamplesRequired: to.Ptr[int32](3),
	// 				},
	// 				TrafficRestorationTimeToHealedOrNewEndpointsInMinutes: to.Ptr[int32](5),
	// 				DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
	// 				ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
	// 			},
	// 	}},
	// }
}

Output:

func (*AFDOriginGroupsClient) NewListResourceUsagePager 

func (client *AFDOriginGroupsClient) NewListResourceUsagePager(resourceGroupName string, profileName string, originGroupName string, options *AFDOriginGroupsClientListResourceUsageOptions) *runtime.Pager[AFDOriginGroupsClientListResourceUsageResponse]

NewListResourceUsagePager - Checks the quota and actual usage of endpoints under the given Azure Front Door profile..

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • originGroupName - Name of the origin group which is unique within the endpoint.
  • options - AFDOriginGroupsClientListResourceUsageOptions contains the optional parameters for the AFDOriginGroupsClient.NewListResourceUsagePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDOriginGroups_ListResourceUsage.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAFDOriginGroupsClient().NewListResourceUsagePager("RG", "profile1", "origingroup1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.UsagesListResult = armcdn.UsagesListResult{
	// 	Value: []*armcdn.Usage{
	// 		{
	// 			Name: &armcdn.UsageName{
	// 				LocalizedValue: to.Ptr("origin"),
	// 				Value: to.Ptr("origin"),
	// 			},
	// 			CurrentValue: to.Ptr[int64](0),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/origingroups/origingroup1/origins/origin1"),
	// 			Limit: to.Ptr[int64](25),
	// 			Unit: to.Ptr(armcdn.UsageUnitCount),
	// 	}},
	// }
}

Output:

type AFDOriginGroupsClientBeginCreateOptions 

type AFDOriginGroupsClientBeginCreateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AFDOriginGroupsClientBeginCreateOptions contains the optional parameters for the AFDOriginGroupsClient.BeginCreate method.

type AFDOriginGroupsClientBeginDeleteOptions 

type AFDOriginGroupsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AFDOriginGroupsClientBeginDeleteOptions contains the optional parameters for the AFDOriginGroupsClient.BeginDelete method.

type AFDOriginGroupsClientBeginUpdateOptions 

type AFDOriginGroupsClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AFDOriginGroupsClientBeginUpdateOptions contains the optional parameters for the AFDOriginGroupsClient.BeginUpdate method.

type AFDOriginGroupsClientCreateResponse 

type AFDOriginGroupsClientCreateResponse struct {
	// AFDOrigin group comprising of origins is used for load balancing to origins when the content cannot be served from Azure
	// Front Door.
	AFDOriginGroup
}

AFDOriginGroupsClientCreateResponse contains the response from method AFDOriginGroupsClient.BeginCreate.

type AFDOriginGroupsClientDeleteResponse 

type AFDOriginGroupsClientDeleteResponse struct {
}

AFDOriginGroupsClientDeleteResponse contains the response from method AFDOriginGroupsClient.BeginDelete.

type AFDOriginGroupsClientGetOptions 

type AFDOriginGroupsClientGetOptions struct {
}

AFDOriginGroupsClientGetOptions contains the optional parameters for the AFDOriginGroupsClient.Get method.

type AFDOriginGroupsClientGetResponse 

type AFDOriginGroupsClientGetResponse struct {
	// AFDOrigin group comprising of origins is used for load balancing to origins when the content cannot be served from Azure
	// Front Door.
	AFDOriginGroup
}

AFDOriginGroupsClientGetResponse contains the response from method AFDOriginGroupsClient.Get.

type AFDOriginGroupsClientListByProfileOptions 

type AFDOriginGroupsClientListByProfileOptions struct {
}

AFDOriginGroupsClientListByProfileOptions contains the optional parameters for the AFDOriginGroupsClient.NewListByProfilePager method.

type AFDOriginGroupsClientListByProfileResponse 

type AFDOriginGroupsClientListByProfileResponse struct {
	// Result of the request to list origin groups. It contains a list of origin groups objects and a URL link to get the next
	// set of results.
	AFDOriginGroupListResult
}

AFDOriginGroupsClientListByProfileResponse contains the response from method AFDOriginGroupsClient.NewListByProfilePager.

type AFDOriginGroupsClientListResourceUsageOptions 

type AFDOriginGroupsClientListResourceUsageOptions struct {
}

AFDOriginGroupsClientListResourceUsageOptions contains the optional parameters for the AFDOriginGroupsClient.NewListResourceUsagePager method.

type AFDOriginGroupsClientListResourceUsageResponse 

type AFDOriginGroupsClientListResourceUsageResponse struct {
	// The list usages operation response.
	UsagesListResult
}

AFDOriginGroupsClientListResourceUsageResponse contains the response from method AFDOriginGroupsClient.NewListResourceUsagePager.

type AFDOriginGroupsClientUpdateResponse 

type AFDOriginGroupsClientUpdateResponse struct {
	// AFDOrigin group comprising of origins is used for load balancing to origins when the content cannot be served from Azure
	// Front Door.
	AFDOriginGroup
}

AFDOriginGroupsClientUpdateResponse contains the response from method AFDOriginGroupsClient.BeginUpdate.

type AFDOriginListResult 

type AFDOriginListResult struct {
	// URL to get the next set of origin objects if there are any.
	NextLink *string

	// READ-ONLY; List of Azure Front Door origins within an Azure Front Door endpoint
	Value []*AFDOrigin
}

AFDOriginListResult - Result of the request to list origins. It contains a list of origin objects and a URL link to get the next set of results.

func (AFDOriginListResult) MarshalJSON 

func (a AFDOriginListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDOriginListResult.

func (*AFDOriginListResult) UnmarshalJSON 

func (a *AFDOriginListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDOriginListResult.

type AFDOriginProperties 

type AFDOriginProperties struct {
	// Resource reference to the Azure origin resource.
	AzureOrigin *ResourceReference

	// Whether to enable health probes to be made against backends defined under backendPools. Health probes can only be disabled
	// if there is a single enabled backend in single enabled backend pool.
	EnabledState *EnabledState

	// Whether to enable certificate name check at origin level
	EnforceCertificateNameCheck *bool

	// The value of the HTTP port. Must be between 1 and 65535.
	HTTPPort *int32

	// The value of the HTTPS port. Must be between 1 and 65535.
	HTTPSPort *int32

	// The address of the origin. Domain names, IPv4 addresses, and IPv6 addresses are supported.This should be unique across
	// all origins in an endpoint.
	HostName *string

	// The host header value sent to the origin with each request. If you leave this blank, the request hostname determines this
	// value. Azure Front Door origins, such as Web Apps, Blob Storage, and Cloud
	// Services require this host header value to match the origin hostname by default. This overrides the host header defined
	// at Endpoint
	OriginHostHeader *string

	// Priority of origin in given origin group for load balancing. Higher priorities will not be used for load balancing if any
	// lower priority origin is healthy.Must be between 1 and 5
	Priority *int32

	// The properties of the private link resource for private origin.
	SharedPrivateLinkResource *SharedPrivateLinkResourceProperties

	// Weight of the origin in given origin group for load balancing. Must be between 1 and 1000
	Weight *int32

	// READ-ONLY
	DeploymentStatus *DeploymentStatus

	// READ-ONLY; The name of the origin group which contains this origin.
	OriginGroupName *string

	// READ-ONLY; Provisioning status
	ProvisioningState *AfdProvisioningState
}

AFDOriginProperties - The JSON object that contains the properties of the origin.

func (AFDOriginProperties) MarshalJSON 

func (a AFDOriginProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDOriginProperties.

func (*AFDOriginProperties) UnmarshalJSON 

func (a *AFDOriginProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDOriginProperties.

type AFDOriginUpdateParameters 

type AFDOriginUpdateParameters struct {
	// The JSON object that contains the properties of the origin.
	Properties *AFDOriginUpdatePropertiesParameters
}

AFDOriginUpdateParameters - AFDOrigin properties needed for origin update.

func (AFDOriginUpdateParameters) MarshalJSON 

func (a AFDOriginUpdateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDOriginUpdateParameters.

func (*AFDOriginUpdateParameters) UnmarshalJSON 

func (a *AFDOriginUpdateParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDOriginUpdateParameters.

type AFDOriginUpdatePropertiesParameters 

type AFDOriginUpdatePropertiesParameters struct {
	// Resource reference to the Azure origin resource.
	AzureOrigin *ResourceReference

	// Whether to enable health probes to be made against backends defined under backendPools. Health probes can only be disabled
	// if there is a single enabled backend in single enabled backend pool.
	EnabledState *EnabledState

	// Whether to enable certificate name check at origin level
	EnforceCertificateNameCheck *bool

	// The value of the HTTP port. Must be between 1 and 65535.
	HTTPPort *int32

	// The value of the HTTPS port. Must be between 1 and 65535.
	HTTPSPort *int32

	// The address of the origin. Domain names, IPv4 addresses, and IPv6 addresses are supported.This should be unique across
	// all origins in an endpoint.
	HostName *string

	// The host header value sent to the origin with each request. If you leave this blank, the request hostname determines this
	// value. Azure Front Door origins, such as Web Apps, Blob Storage, and Cloud
	// Services require this host header value to match the origin hostname by default. This overrides the host header defined
	// at Endpoint
	OriginHostHeader *string

	// Priority of origin in given origin group for load balancing. Higher priorities will not be used for load balancing if any
	// lower priority origin is healthy.Must be between 1 and 5
	Priority *int32

	// The properties of the private link resource for private origin.
	SharedPrivateLinkResource *SharedPrivateLinkResourceProperties

	// Weight of the origin in given origin group for load balancing. Must be between 1 and 1000
	Weight *int32

	// READ-ONLY; The name of the origin group which contains this origin.
	OriginGroupName *string
}

AFDOriginUpdatePropertiesParameters - The JSON object that contains the properties of the origin.

func (AFDOriginUpdatePropertiesParameters) MarshalJSON 

func (a AFDOriginUpdatePropertiesParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AFDOriginUpdatePropertiesParameters.

func (*AFDOriginUpdatePropertiesParameters) UnmarshalJSON 

func (a *AFDOriginUpdatePropertiesParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AFDOriginUpdatePropertiesParameters.

type AFDOriginsClient 

type AFDOriginsClient struct {
	// contains filtered or unexported fields
}

AFDOriginsClient contains the methods for the AFDOrigins group. Don't use this type directly, use NewAFDOriginsClient() instead.

func NewAFDOriginsClient 

func NewAFDOriginsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AFDOriginsClient, error)

NewAFDOriginsClient creates a new instance of AFDOriginsClient with the specified values.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AFDOriginsClient) BeginCreate 

func (client *AFDOriginsClient) BeginCreate(ctx context.Context, resourceGroupName string, profileName string, originGroupName string, originName string, origin AFDOrigin, options *AFDOriginsClientBeginCreateOptions) (*runtime.Poller[AFDOriginsClientCreateResponse], error)

BeginCreate - Creates a new origin within the specified origin group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • originGroupName - Name of the origin group which is unique within the profile.
  • originName - Name of the origin that is unique within the profile.
  • origin - Origin properties
  • options - AFDOriginsClientBeginCreateOptions contains the optional parameters for the AFDOriginsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDOrigins_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAFDOriginsClient().BeginCreate(ctx, "RG", "profile1", "origingroup1", "origin1", armcdn.AFDOrigin{
	Properties: &armcdn.AFDOriginProperties{
		EnabledState:     to.Ptr(armcdn.EnabledStateEnabled),
		HostName:         to.Ptr("host1.blob.core.windows.net"),
		HTTPPort:         to.Ptr[int32](80),
		HTTPSPort:        to.Ptr[int32](443),
		OriginHostHeader: to.Ptr("host1.foo.com"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AFDOrigin = armcdn.AFDOrigin{
// 	Name: to.Ptr("origin1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/origingroups/origins"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/origingroups/origingroup1/origins/origin1"),
// 	Properties: &armcdn.AFDOriginProperties{
// 		EnabledState: to.Ptr(armcdn.EnabledStateEnabled),
// 		EnforceCertificateNameCheck: to.Ptr(true),
// 		HostName: to.Ptr("host1.blob.core.windows.net"),
// 		HTTPPort: to.Ptr[int32](80),
// 		HTTPSPort: to.Ptr[int32](443),
// 		OriginGroupName: to.Ptr("origingroup1"),
// 		OriginHostHeader: to.Ptr("host1.foo.com"),
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 	},
// }

Output:

func (*AFDOriginsClient) BeginDelete 

func (client *AFDOriginsClient) BeginDelete(ctx context.Context, resourceGroupName string, profileName string, originGroupName string, originName string, options *AFDOriginsClientBeginDeleteOptions) (*runtime.Poller[AFDOriginsClientDeleteResponse], error)

BeginDelete - Deletes an existing origin within an origin group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • originGroupName - Name of the origin group which is unique within the profile.
  • originName - Name of the origin which is unique within the profile.
  • options - AFDOriginsClientBeginDeleteOptions contains the optional parameters for the AFDOriginsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDOrigins_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAFDOriginsClient().BeginDelete(ctx, "RG", "profile1", "origingroup1", "origin1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*AFDOriginsClient) BeginUpdate 

func (client *AFDOriginsClient) BeginUpdate(ctx context.Context, resourceGroupName string, profileName string, originGroupName string, originName string, originUpdateProperties AFDOriginUpdateParameters, options *AFDOriginsClientBeginUpdateOptions) (*runtime.Poller[AFDOriginsClientUpdateResponse], error)

BeginUpdate - Updates an existing origin within an origin group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • originGroupName - Name of the origin group which is unique within the profile.
  • originName - Name of the origin which is unique within the profile.
  • originUpdateProperties - Origin properties
  • options - AFDOriginsClientBeginUpdateOptions contains the optional parameters for the AFDOriginsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDOrigins_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAFDOriginsClient().BeginUpdate(ctx, "RG", "profile1", "origingroup1", "origin1", armcdn.AFDOriginUpdateParameters{
	Properties: &armcdn.AFDOriginUpdatePropertiesParameters{
		EnabledState: to.Ptr(armcdn.EnabledStateEnabled),
		HostName:     to.Ptr("host1.blob.core.windows.net"),
		HTTPPort:     to.Ptr[int32](80),
		HTTPSPort:    to.Ptr[int32](443),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AFDOrigin = armcdn.AFDOrigin{
// 	Name: to.Ptr("origin1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/origingroups/origins"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/origingroups/origingroup1/origins/origin1"),
// 	Properties: &armcdn.AFDOriginProperties{
// 		EnabledState: to.Ptr(armcdn.EnabledStateEnabled),
// 		EnforceCertificateNameCheck: to.Ptr(true),
// 		HostName: to.Ptr("host1.blob.core.windows.net"),
// 		HTTPPort: to.Ptr[int32](80),
// 		HTTPSPort: to.Ptr[int32](443),
// 		OriginGroupName: to.Ptr("origingroup1"),
// 		OriginHostHeader: to.Ptr("host1.foo.com"),
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 	},
// }

Output:

func (*AFDOriginsClient) Get 

func (client *AFDOriginsClient) Get(ctx context.Context, resourceGroupName string, profileName string, originGroupName string, originName string, options *AFDOriginsClientGetOptions) (AFDOriginsClientGetResponse, error)

Get - Gets an existing origin within an origin group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • originGroupName - Name of the origin group which is unique within the profile.
  • originName - Name of the origin which is unique within the profile.
  • options - AFDOriginsClientGetOptions contains the optional parameters for the AFDOriginsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDOrigins_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAFDOriginsClient().Get(ctx, "RG", "profile1", "origingroup1", "origin1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AFDOrigin = armcdn.AFDOrigin{
// 	Name: to.Ptr("origin1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/origingroups/origins"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/origingroups/origingroup1/origins/origin1"),
// 	Properties: &armcdn.AFDOriginProperties{
// 		EnabledState: to.Ptr(armcdn.EnabledStateEnabled),
// 		EnforceCertificateNameCheck: to.Ptr(true),
// 		HostName: to.Ptr("host1.blob.core.windows.net"),
// 		HTTPPort: to.Ptr[int32](80),
// 		HTTPSPort: to.Ptr[int32](443),
// 		OriginGroupName: to.Ptr("origingroup1"),
// 		OriginHostHeader: to.Ptr("host1.foo.com"),
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 	},
// }

Output:

func (*AFDOriginsClient) NewListByOriginGroupPager 

func (client *AFDOriginsClient) NewListByOriginGroupPager(resourceGroupName string, profileName string, originGroupName string, options *AFDOriginsClientListByOriginGroupOptions) *runtime.Pager[AFDOriginsClientListByOriginGroupResponse]

NewListByOriginGroupPager - Lists all of the existing origins within an origin group.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • originGroupName - Name of the origin group which is unique within the profile.
  • options - AFDOriginsClientListByOriginGroupOptions contains the optional parameters for the AFDOriginsClient.NewListByOriginGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDOrigins_ListByOriginGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAFDOriginsClient().NewListByOriginGroupPager("RG", "profile1", "origingroup1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.AFDOriginListResult = armcdn.AFDOriginListResult{
	// 	Value: []*armcdn.AFDOrigin{
	// 		{
	// 			Name: to.Ptr("origin1"),
	// 			Type: to.Ptr("Microsoft.Cdn/profiles/origingroups/origins"),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/origingroups/origingroup1/origins/origin1"),
	// 			Properties: &armcdn.AFDOriginProperties{
	// 				EnabledState: to.Ptr(armcdn.EnabledStateEnabled),
	// 				EnforceCertificateNameCheck: to.Ptr(true),
	// 				HostName: to.Ptr("host1.blob.core.windows.net"),
	// 				HTTPPort: to.Ptr[int32](80),
	// 				HTTPSPort: to.Ptr[int32](443),
	// 				OriginGroupName: to.Ptr("origingroup1"),
	// 				OriginHostHeader: to.Ptr("host1.foo.com"),
	// 				DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
	// 				ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
	// 			},
	// 	}},
	// }
}

Output:

type AFDOriginsClientBeginCreateOptions 

type AFDOriginsClientBeginCreateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AFDOriginsClientBeginCreateOptions contains the optional parameters for the AFDOriginsClient.BeginCreate method.

type AFDOriginsClientBeginDeleteOptions 

type AFDOriginsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AFDOriginsClientBeginDeleteOptions contains the optional parameters for the AFDOriginsClient.BeginDelete method.

type AFDOriginsClientBeginUpdateOptions 

type AFDOriginsClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AFDOriginsClientBeginUpdateOptions contains the optional parameters for the AFDOriginsClient.BeginUpdate method.

type AFDOriginsClientCreateResponse 

type AFDOriginsClientCreateResponse struct {
	// Azure Front Door origin is the source of the content being delivered via Azure Front Door. When the edge nodes represented
	// by an endpoint do not have the requested content cached, they attempt to fetch it from one or more of the configured origins.
	AFDOrigin
}

AFDOriginsClientCreateResponse contains the response from method AFDOriginsClient.BeginCreate.

type AFDOriginsClientDeleteResponse 

type AFDOriginsClientDeleteResponse struct {
}

AFDOriginsClientDeleteResponse contains the response from method AFDOriginsClient.BeginDelete.

type AFDOriginsClientGetOptions 

type AFDOriginsClientGetOptions struct {
}

AFDOriginsClientGetOptions contains the optional parameters for the AFDOriginsClient.Get method.

type AFDOriginsClientGetResponse 

type AFDOriginsClientGetResponse struct {
	// Azure Front Door origin is the source of the content being delivered via Azure Front Door. When the edge nodes represented
	// by an endpoint do not have the requested content cached, they attempt to fetch it from one or more of the configured origins.
	AFDOrigin
}

AFDOriginsClientGetResponse contains the response from method AFDOriginsClient.Get.

type AFDOriginsClientListByOriginGroupOptions 

type AFDOriginsClientListByOriginGroupOptions struct {
}

AFDOriginsClientListByOriginGroupOptions contains the optional parameters for the AFDOriginsClient.NewListByOriginGroupPager method.

type AFDOriginsClientListByOriginGroupResponse 

type AFDOriginsClientListByOriginGroupResponse struct {
	// Result of the request to list origins. It contains a list of origin objects and a URL link to get the next set of results.
	AFDOriginListResult
}

AFDOriginsClientListByOriginGroupResponse contains the response from method AFDOriginsClient.NewListByOriginGroupPager.

type AFDOriginsClientUpdateResponse 

type AFDOriginsClientUpdateResponse struct {
	// Azure Front Door origin is the source of the content being delivered via Azure Front Door. When the edge nodes represented
	// by an endpoint do not have the requested content cached, they attempt to fetch it from one or more of the configured origins.
	AFDOrigin
}

AFDOriginsClientUpdateResponse contains the response from method AFDOriginsClient.BeginUpdate.

type AFDProfilesClient 

type AFDProfilesClient struct {
	// contains filtered or unexported fields
}

AFDProfilesClient contains the methods for the AFDProfiles group. Don't use this type directly, use NewAFDProfilesClient() instead.

func NewAFDProfilesClient 

func NewAFDProfilesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AFDProfilesClient, error)

NewAFDProfilesClient creates a new instance of AFDProfilesClient with the specified values.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AFDProfilesClient) BeginUpgrade 

func (client *AFDProfilesClient) BeginUpgrade(ctx context.Context, resourceGroupName string, profileName string, profileUpgradeParameters ProfileUpgradeParameters, options *AFDProfilesClientBeginUpgradeOptions) (*runtime.Poller[AFDProfilesClientUpgradeResponse], error)

BeginUpgrade - Upgrade a profile from StandardAzureFrontDoor to PremiumAzureFrontDoor. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium which is unique within the resource group.
  • profileUpgradeParameters - Profile upgrade input parameter.
  • options - AFDProfilesClientBeginUpgradeOptions contains the optional parameters for the AFDProfilesClient.BeginUpgrade method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDProfiles_Upgrade.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAFDProfilesClient().BeginUpgrade(ctx, "RG", "profile1", armcdn.ProfileUpgradeParameters{
	WafMappingList: []*armcdn.ProfileChangeSKUWafMapping{
		{
			ChangeToWafPolicy: &armcdn.ResourceReference{
				ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Network/frontdoorwebapplicationfirewallpolicies/waf2"),
			},
			SecurityPolicyName: to.Ptr("securityPolicy1"),
		}},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Profile = armcdn.Profile{
// 	Name: to.Ptr("profile1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1"),
// 	Location: to.Ptr("Global"),
// 	Tags: map[string]*string{
// 	},
// 	Kind: to.Ptr("frontdoor"),
// 	Properties: &armcdn.ProfileProperties{
// 		ExtendedProperties: map[string]*string{
// 		},
// 		FrontDoorID: to.Ptr("id"),
// 		OriginResponseTimeoutSeconds: to.Ptr[int32](60),
// 		ProvisioningState: to.Ptr(armcdn.ProfileProvisioningStateSucceeded),
// 		ResourceState: to.Ptr(armcdn.ProfileResourceState("Enabled")),
// 	},
// 	SKU: &armcdn.SKU{
// 		Name: to.Ptr(armcdn.SKUNameStandardAzureFrontDoor),
// 	},
// }

Output:

func (*AFDProfilesClient) CheckEndpointNameAvailability 

func (client *AFDProfilesClient) CheckEndpointNameAvailability(ctx context.Context, resourceGroupName string, profileName string, checkEndpointNameAvailabilityInput CheckEndpointNameAvailabilityInput, options *AFDProfilesClientCheckEndpointNameAvailabilityOptions) (AFDProfilesClientCheckEndpointNameAvailabilityResponse, error)

CheckEndpointNameAvailability - Check the availability of an afdx endpoint name, and return the globally unique endpoint host name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium which is unique within the resource group.
  • checkEndpointNameAvailabilityInput - Input to check.
  • options - AFDProfilesClientCheckEndpointNameAvailabilityOptions contains the optional parameters for the AFDProfilesClient.CheckEndpointNameAvailability method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDProfiles_CheckEndpointNameAvailability.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAFDProfilesClient().CheckEndpointNameAvailability(ctx, "myResourceGroup", "profile1", armcdn.CheckEndpointNameAvailabilityInput{
	Name:                              to.Ptr("sampleName"),
	Type:                              to.Ptr(armcdn.ResourceTypeMicrosoftCdnProfilesAfdEndpoints),
	AutoGeneratedDomainNameLabelScope: to.Ptr(armcdn.AutoGeneratedDomainNameLabelScopeTenantReuse),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.CheckEndpointNameAvailabilityOutput = armcdn.CheckEndpointNameAvailabilityOutput{
// 	AvailableHostname: to.Ptr(""),
// 	Message: to.Ptr("Name not available"),
// 	NameAvailable: to.Ptr(false),
// 	Reason: to.Ptr("Name is already in use"),
// }

Output:

func (*AFDProfilesClient) CheckHostNameAvailability 

func (client *AFDProfilesClient) CheckHostNameAvailability(ctx context.Context, resourceGroupName string, profileName string, checkHostNameAvailabilityInput CheckHostNameAvailabilityInput, options *AFDProfilesClientCheckHostNameAvailabilityOptions) (AFDProfilesClientCheckHostNameAvailabilityResponse, error)

CheckHostNameAvailability - Validates the custom domain mapping to ensure it maps to the correct Azure Front Door endpoint in DNS. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • checkHostNameAvailabilityInput - Custom domain to be validated.
  • options - AFDProfilesClientCheckHostNameAvailabilityOptions contains the optional parameters for the AFDProfilesClient.CheckHostNameAvailability method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDProfiles_CheckHostNameAvailability.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAFDProfilesClient().CheckHostNameAvailability(ctx, "RG", "profile1", armcdn.CheckHostNameAvailabilityInput{
	HostName: to.Ptr("www.someDomain.net"),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.CheckNameAvailabilityOutput = armcdn.CheckNameAvailabilityOutput{
// 	Message: to.Ptr("The hostname 'www.someDomain.net' is already owned by another profile."),
// 	NameAvailable: to.Ptr(false),
// 	Reason: to.Ptr("Conflict"),
// }

Output:

func (*AFDProfilesClient) NewListResourceUsagePager 

func (client *AFDProfilesClient) NewListResourceUsagePager(resourceGroupName string, profileName string, options *AFDProfilesClientListResourceUsageOptions) *runtime.Pager[AFDProfilesClientListResourceUsageResponse]

NewListResourceUsagePager - Checks the quota and actual usage of endpoints under the given Azure Front Door profile.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • options - AFDProfilesClientListResourceUsageOptions contains the optional parameters for the AFDProfilesClient.NewListResourceUsagePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDProfiles_ListResourceUsage.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAFDProfilesClient().NewListResourceUsagePager("RG", "profile1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.UsagesListResult = armcdn.UsagesListResult{
	// 	Value: []*armcdn.Usage{
	// 		{
	// 			Name: &armcdn.UsageName{
	// 				LocalizedValue: to.Ptr("afdendpoint"),
	// 				Value: to.Ptr("afdendpoint"),
	// 			},
	// 			CurrentValue: to.Ptr[int64](0),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/afdendpoints/endpoint1"),
	// 			Limit: to.Ptr[int64](25),
	// 			Unit: to.Ptr(armcdn.UsageUnitCount),
	// 	}},
	// }
}

Output:

func (*AFDProfilesClient) ValidateSecret 

func (client *AFDProfilesClient) ValidateSecret(ctx context.Context, resourceGroupName string, profileName string, validateSecretInput ValidateSecretInput, options *AFDProfilesClientValidateSecretOptions) (AFDProfilesClientValidateSecretResponse, error)

ValidateSecret - Validate a Secret in the profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium which is unique within the resource group.
  • validateSecretInput - The Secret source.
  • options - AFDProfilesClientValidateSecretOptions contains the optional parameters for the AFDProfilesClient.ValidateSecret method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/AFDProfiles_ValidateSecret.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAFDProfilesClient().ValidateSecret(ctx, "RG", "profile1", armcdn.ValidateSecretInput{
	SecretSource: &armcdn.ResourceReference{
		ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.KeyVault/vault/kvName/certificate/certName"),
	},
	SecretType: to.Ptr(armcdn.SecretTypeCustomerCertificate),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ValidateSecretOutput = armcdn.ValidateSecretOutput{
// 	Status: to.Ptr(armcdn.StatusValid),
// }

Output:

type AFDProfilesClientBeginUpgradeOptions 

type AFDProfilesClientBeginUpgradeOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AFDProfilesClientBeginUpgradeOptions contains the optional parameters for the AFDProfilesClient.BeginUpgrade method.

type AFDProfilesClientCheckEndpointNameAvailabilityOptions 

type AFDProfilesClientCheckEndpointNameAvailabilityOptions struct {
}

AFDProfilesClientCheckEndpointNameAvailabilityOptions contains the optional parameters for the AFDProfilesClient.CheckEndpointNameAvailability method.

type AFDProfilesClientCheckEndpointNameAvailabilityResponse 

type AFDProfilesClientCheckEndpointNameAvailabilityResponse struct {
	// Output of check name availability API.
	CheckEndpointNameAvailabilityOutput
}

AFDProfilesClientCheckEndpointNameAvailabilityResponse contains the response from method AFDProfilesClient.CheckEndpointNameAvailability.

type AFDProfilesClientCheckHostNameAvailabilityOptions 

type AFDProfilesClientCheckHostNameAvailabilityOptions struct {
}

AFDProfilesClientCheckHostNameAvailabilityOptions contains the optional parameters for the AFDProfilesClient.CheckHostNameAvailability method.

type AFDProfilesClientCheckHostNameAvailabilityResponse 

type AFDProfilesClientCheckHostNameAvailabilityResponse struct {
	// Output of check name availability API.
	CheckNameAvailabilityOutput
}

AFDProfilesClientCheckHostNameAvailabilityResponse contains the response from method AFDProfilesClient.CheckHostNameAvailability.

type AFDProfilesClientListResourceUsageOptions 

type AFDProfilesClientListResourceUsageOptions struct {
}

AFDProfilesClientListResourceUsageOptions contains the optional parameters for the AFDProfilesClient.NewListResourceUsagePager method.

type AFDProfilesClientListResourceUsageResponse 

type AFDProfilesClientListResourceUsageResponse struct {
	// The list usages operation response.
	UsagesListResult
}

AFDProfilesClientListResourceUsageResponse contains the response from method AFDProfilesClient.NewListResourceUsagePager.

type AFDProfilesClientUpgradeResponse 

type AFDProfilesClientUpgradeResponse struct {
	// A profile is a logical grouping of endpoints that share the same settings.
	Profile
}

AFDProfilesClientUpgradeResponse contains the response from method AFDProfilesClient.BeginUpgrade.

type AFDProfilesClientValidateSecretOptions 

type AFDProfilesClientValidateSecretOptions struct {
}

AFDProfilesClientValidateSecretOptions contains the optional parameters for the AFDProfilesClient.ValidateSecret method.

type AFDProfilesClientValidateSecretResponse 

type AFDProfilesClientValidateSecretResponse struct {
	// Output of the validated secret.
	ValidateSecretOutput
}

AFDProfilesClientValidateSecretResponse contains the response from method AFDProfilesClient.ValidateSecret.

type ActionType 

type ActionType string

ActionType - Defines the action to take on rule match. 

const (
	ActionTypeAllow    ActionType = "Allow"
	ActionTypeBlock    ActionType = "Block"
	ActionTypeLog      ActionType = "Log"
	ActionTypeRedirect ActionType = "Redirect"
)

func PossibleActionTypeValues 

func PossibleActionTypeValues() []ActionType

PossibleActionTypeValues returns the possible values for the ActionType const type.

type ActivatedResourceReference 

type ActivatedResourceReference struct {
	// Resource ID.
	ID *string

	// READ-ONLY; Whether the resource is active or inactive
	IsActive *bool
}

ActivatedResourceReference - Reference to another resource along with its state.

func (ActivatedResourceReference) MarshalJSON 

func (a ActivatedResourceReference) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ActivatedResourceReference.

func (*ActivatedResourceReference) UnmarshalJSON 

func (a *ActivatedResourceReference) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ActivatedResourceReference.

type AfdCertificateType 

type AfdCertificateType string

AfdCertificateType - Defines the source of the SSL certificate. 

const (
	AfdCertificateTypeAzureFirstPartyManagedCertificate AfdCertificateType = "AzureFirstPartyManagedCertificate"
	AfdCertificateTypeCustomerCertificate               AfdCertificateType = "CustomerCertificate"
	AfdCertificateTypeManagedCertificate                AfdCertificateType = "ManagedCertificate"
)

func PossibleAfdCertificateTypeValues 

func PossibleAfdCertificateTypeValues() []AfdCertificateType

PossibleAfdCertificateTypeValues returns the possible values for the AfdCertificateType const type.

type AfdMinimumTLSVersion 

type AfdMinimumTLSVersion string

AfdMinimumTLSVersion - TLS protocol version that will be used for Https 

const (
	AfdMinimumTLSVersionTLS10 AfdMinimumTLSVersion = "TLS10"
	AfdMinimumTLSVersionTLS12 AfdMinimumTLSVersion = "TLS12"
)

func PossibleAfdMinimumTLSVersionValues 

func PossibleAfdMinimumTLSVersionValues() []AfdMinimumTLSVersion

PossibleAfdMinimumTLSVersionValues returns the possible values for the AfdMinimumTLSVersion const type.

type AfdProvisioningState 

type AfdProvisioningState string

AfdProvisioningState - Provisioning status 

const (
	AfdProvisioningStateCreating  AfdProvisioningState = "Creating"
	AfdProvisioningStateDeleting  AfdProvisioningState = "Deleting"
	AfdProvisioningStateFailed    AfdProvisioningState = "Failed"
	AfdProvisioningStateSucceeded AfdProvisioningState = "Succeeded"
	AfdProvisioningStateUpdating  AfdProvisioningState = "Updating"
)

func PossibleAfdProvisioningStateValues 

func PossibleAfdProvisioningStateValues() []AfdProvisioningState

PossibleAfdProvisioningStateValues returns the possible values for the AfdProvisioningState const type.

type AfdPurgeParameters 

type AfdPurgeParameters struct {
	// REQUIRED; The path to the content to be purged. Can describe a file path or a wild card directory.
	ContentPaths []*string

	// List of domains.
	Domains []*string
}

AfdPurgeParameters - Parameters required for content purge.

func (AfdPurgeParameters) MarshalJSON 

func (a AfdPurgeParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AfdPurgeParameters.

func (*AfdPurgeParameters) UnmarshalJSON 

func (a *AfdPurgeParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AfdPurgeParameters.

type AfdQueryStringCachingBehavior 

type AfdQueryStringCachingBehavior string

AfdQueryStringCachingBehavior - Defines how Frontdoor caches requests that include query strings. You can ignore any query strings when caching, ignore specific query strings, cache every request with a unique URL, or cache specific query strings. 

const (
	AfdQueryStringCachingBehaviorIgnoreQueryString            AfdQueryStringCachingBehavior = "IgnoreQueryString"
	AfdQueryStringCachingBehaviorIgnoreSpecifiedQueryStrings  AfdQueryStringCachingBehavior = "IgnoreSpecifiedQueryStrings"
	AfdQueryStringCachingBehaviorIncludeSpecifiedQueryStrings AfdQueryStringCachingBehavior = "IncludeSpecifiedQueryStrings"
	AfdQueryStringCachingBehaviorUseQueryString               AfdQueryStringCachingBehavior = "UseQueryString"
)

func PossibleAfdQueryStringCachingBehaviorValues 

func PossibleAfdQueryStringCachingBehaviorValues() []AfdQueryStringCachingBehavior

PossibleAfdQueryStringCachingBehaviorValues returns the possible values for the AfdQueryStringCachingBehavior const type.

type AfdRouteCacheConfiguration 

type AfdRouteCacheConfiguration struct {
	// compression settings.
	CompressionSettings *CompressionSettings

	// query parameters to include or exclude (comma separated).
	QueryParameters *string

	// Defines how Frontdoor caches requests that include query strings. You can ignore any query strings when caching, ignore
	// specific query strings, cache every request with a unique URL, or cache specific
	// query strings.
	QueryStringCachingBehavior *AfdQueryStringCachingBehavior
}

AfdRouteCacheConfiguration - Caching settings for a caching-type route. To disable caching, do not provide a cacheConfiguration object.

func (AfdRouteCacheConfiguration) MarshalJSON 

func (a AfdRouteCacheConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AfdRouteCacheConfiguration.

func (*AfdRouteCacheConfiguration) UnmarshalJSON 

func (a *AfdRouteCacheConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AfdRouteCacheConfiguration.

type Algorithm 

type Algorithm string

Algorithm - Algorithm to use for URL signing 

const (
	AlgorithmSHA256 Algorithm = "SHA256"
)

func PossibleAlgorithmValues 

func PossibleAlgorithmValues() []Algorithm

PossibleAlgorithmValues returns the possible values for the Algorithm const type.

type AutoGeneratedDomainNameLabelScope 

type AutoGeneratedDomainNameLabelScope string

AutoGeneratedDomainNameLabelScope - Indicates the endpoint name reuse scope. The default value is TenantReuse. 

const (
	AutoGeneratedDomainNameLabelScopeNoReuse            AutoGeneratedDomainNameLabelScope = "NoReuse"
	AutoGeneratedDomainNameLabelScopeResourceGroupReuse AutoGeneratedDomainNameLabelScope = "ResourceGroupReuse"
	AutoGeneratedDomainNameLabelScopeSubscriptionReuse  AutoGeneratedDomainNameLabelScope = "SubscriptionReuse"
	AutoGeneratedDomainNameLabelScopeTenantReuse        AutoGeneratedDomainNameLabelScope = "TenantReuse"
)

func PossibleAutoGeneratedDomainNameLabelScopeValues 

func PossibleAutoGeneratedDomainNameLabelScopeValues() []AutoGeneratedDomainNameLabelScope

PossibleAutoGeneratedDomainNameLabelScopeValues returns the possible values for the AutoGeneratedDomainNameLabelScope const type.

type AzureFirstPartyManagedCertificateParameters 

type AzureFirstPartyManagedCertificateParameters struct {
	// REQUIRED; The type of the secret resource.
	Type *SecretType

	// The list of SANs.
	SubjectAlternativeNames []*string

	// READ-ONLY; Certificate issuing authority.
	CertificateAuthority *string

	// READ-ONLY; Certificate expiration date.
	ExpirationDate *string

	// READ-ONLY; Resource reference to the Azure Key Vault certificate. Expected to be in format of
	// /subscriptions/{​​​​​​​​​subscriptionId}​​​​​​​​​/resourceGroups/{​​​​​​​​​resourceGroupName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​/providers/Microsoft.KeyVault/vaults/{vaultName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​/secrets/{certificateName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​
	SecretSource *ResourceReference

	// READ-ONLY; Subject name in the certificate.
	Subject *string

	// READ-ONLY; Certificate thumbprint.
	Thumbprint *string
}

AzureFirstPartyManagedCertificateParameters - Azure FirstParty Managed Certificate provided by other first party resource providers to enable HTTPS.

func (*AzureFirstPartyManagedCertificateParameters) GetSecretParameters 

func (a *AzureFirstPartyManagedCertificateParameters) GetSecretParameters() *SecretParameters

GetSecretParameters implements the SecretParametersClassification interface for type AzureFirstPartyManagedCertificateParameters.

func (AzureFirstPartyManagedCertificateParameters) MarshalJSON 

func (a AzureFirstPartyManagedCertificateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirstPartyManagedCertificateParameters.

func (*AzureFirstPartyManagedCertificateParameters) UnmarshalJSON 

func (a *AzureFirstPartyManagedCertificateParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirstPartyManagedCertificateParameters.

type CacheBehavior 

type CacheBehavior string

CacheBehavior - Caching behavior for the requests 

const (
	CacheBehaviorBypassCache  CacheBehavior = "BypassCache"
	CacheBehaviorOverride     CacheBehavior = "Override"
	CacheBehaviorSetIfMissing CacheBehavior = "SetIfMissing"
)

func PossibleCacheBehaviorValues 

func PossibleCacheBehaviorValues() []CacheBehavior

PossibleCacheBehaviorValues returns the possible values for the CacheBehavior const type.

type CacheConfiguration 

type CacheConfiguration struct {
	// Caching behavior for the requests
	CacheBehavior *RuleCacheBehavior

	// The duration for which the content needs to be cached. Allowed format is [d.]hh:mm:ss
	CacheDuration *string

	// Indicates whether content compression is enabled. If compression is enabled, content will be served as compressed if user
	// requests for a compressed version. Content won't be compressed on
	// AzureFrontDoor when requested content is smaller than 1 byte or larger than 1 MB.
	IsCompressionEnabled *RuleIsCompressionEnabled

	// query parameters to include or exclude (comma separated).
	QueryParameters *string

	// Defines how Frontdoor caches requests that include query strings. You can ignore any query strings when caching, ignore
	// specific query strings, cache every request with a unique URL, or cache specific
	// query strings.
	QueryStringCachingBehavior *RuleQueryStringCachingBehavior
}

CacheConfiguration - Caching settings for a caching-type route. To disable caching, do not provide a cacheConfiguration object.

func (CacheConfiguration) MarshalJSON 

func (c CacheConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CacheConfiguration.

func (*CacheConfiguration) UnmarshalJSON 

func (c *CacheConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CacheConfiguration.

type CacheExpirationActionParameters 

type CacheExpirationActionParameters struct {
	// REQUIRED; Caching behavior for the requests
	CacheBehavior *CacheBehavior

	// REQUIRED; The level at which the content needs to be cached.
	CacheType *CacheType

	// REQUIRED
	TypeName *CacheExpirationActionParametersTypeName

	// The duration for which the content needs to be cached. Allowed format is [d.]hh:mm:ss
	CacheDuration *string
}

CacheExpirationActionParameters - Defines the parameters for the cache expiration action.

func (CacheExpirationActionParameters) MarshalJSON 

func (c CacheExpirationActionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CacheExpirationActionParameters.

func (*CacheExpirationActionParameters) UnmarshalJSON 

func (c *CacheExpirationActionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CacheExpirationActionParameters.

type CacheExpirationActionParametersTypeName 

type CacheExpirationActionParametersTypeName string
const (
	CacheExpirationActionParametersTypeNameDeliveryRuleCacheExpirationActionParameters CacheExpirationActionParametersTypeName = "DeliveryRuleCacheExpirationActionParameters"
)

func PossibleCacheExpirationActionParametersTypeNameValues 

func PossibleCacheExpirationActionParametersTypeNameValues() []CacheExpirationActionParametersTypeName

PossibleCacheExpirationActionParametersTypeNameValues returns the possible values for the CacheExpirationActionParametersTypeName const type.

type CacheKeyQueryStringActionParameters 

type CacheKeyQueryStringActionParameters struct {
	// REQUIRED; Caching behavior for the requests
	QueryStringBehavior *QueryStringBehavior

	// REQUIRED
	TypeName *CacheKeyQueryStringActionParametersTypeName

	// query parameters to include or exclude (comma separated).
	QueryParameters *string
}

CacheKeyQueryStringActionParameters - Defines the parameters for the cache-key query string action.

func (CacheKeyQueryStringActionParameters) MarshalJSON 

func (c CacheKeyQueryStringActionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CacheKeyQueryStringActionParameters.

func (*CacheKeyQueryStringActionParameters) UnmarshalJSON 

func (c *CacheKeyQueryStringActionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CacheKeyQueryStringActionParameters.

type CacheKeyQueryStringActionParametersTypeName 

type CacheKeyQueryStringActionParametersTypeName string
const (
	CacheKeyQueryStringActionParametersTypeNameDeliveryRuleCacheKeyQueryStringBehaviorActionParameters CacheKeyQueryStringActionParametersTypeName = "DeliveryRuleCacheKeyQueryStringBehaviorActionParameters"
)

func PossibleCacheKeyQueryStringActionParametersTypeNameValues 

func PossibleCacheKeyQueryStringActionParametersTypeNameValues() []CacheKeyQueryStringActionParametersTypeName

PossibleCacheKeyQueryStringActionParametersTypeNameValues returns the possible values for the CacheKeyQueryStringActionParametersTypeName const type.

type CacheType 

type CacheType string

CacheType - The level at which the content needs to be cached. 

const (
	CacheTypeAll CacheType = "All"
)

func PossibleCacheTypeValues 

func PossibleCacheTypeValues() []CacheType

PossibleCacheTypeValues returns the possible values for the CacheType const type.

type CanMigrateDefaultSKU 

type CanMigrateDefaultSKU string

CanMigrateDefaultSKU - Recommended sku for the migration 

const (
	CanMigrateDefaultSKUPremiumAzureFrontDoor  CanMigrateDefaultSKU = "Premium_AzureFrontDoor"
	CanMigrateDefaultSKUStandardAzureFrontDoor CanMigrateDefaultSKU = "Standard_AzureFrontDoor"
)

func PossibleCanMigrateDefaultSKUValues 

func PossibleCanMigrateDefaultSKUValues() []CanMigrateDefaultSKU

PossibleCanMigrateDefaultSKUValues returns the possible values for the CanMigrateDefaultSKU const type.

type CanMigrateParameters 

type CanMigrateParameters struct {
	// REQUIRED; Resource reference of the classic cdn profile or classic frontdoor that need to be migrated.
	ClassicResourceReference *ResourceReference
}

CanMigrateParameters - Request body for CanMigrate operation.

func (CanMigrateParameters) MarshalJSON 

func (c CanMigrateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CanMigrateParameters.

func (*CanMigrateParameters) UnmarshalJSON 

func (c *CanMigrateParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CanMigrateParameters.

type CanMigrateProperties 

type CanMigrateProperties struct {
	Errors []*MigrationErrorType

	// READ-ONLY; Flag that says if the profile can be migrated
	CanMigrate *bool

	// READ-ONLY; Recommended sku for the migration
	DefaultSKU *CanMigrateDefaultSKU
}

func (CanMigrateProperties) MarshalJSON 

func (c CanMigrateProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CanMigrateProperties.

func (*CanMigrateProperties) UnmarshalJSON 

func (c *CanMigrateProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CanMigrateProperties.

type CanMigrateResult 

type CanMigrateResult struct {
	Properties *CanMigrateProperties

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource type.
	Type *string
}

CanMigrateResult - Result for canMigrate operation.

func (CanMigrateResult) MarshalJSON 

func (c CanMigrateResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CanMigrateResult.

func (*CanMigrateResult) UnmarshalJSON 

func (c *CanMigrateResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CanMigrateResult.

type CdnCertificateSourceParametersTypeName 

type CdnCertificateSourceParametersTypeName string
const (
	CdnCertificateSourceParametersTypeNameCdnCertificateSourceParameters CdnCertificateSourceParametersTypeName = "CdnCertificateSourceParameters"
)

func PossibleCdnCertificateSourceParametersTypeNameValues 

func PossibleCdnCertificateSourceParametersTypeNameValues() []CdnCertificateSourceParametersTypeName

PossibleCdnCertificateSourceParametersTypeNameValues returns the possible values for the CdnCertificateSourceParametersTypeName const type.

type CertificateSource 

type CertificateSource string

CertificateSource - Defines the source of the SSL certificate. 

const (
	CertificateSourceAzureKeyVault CertificateSource = "AzureKeyVault"
	CertificateSourceCdn           CertificateSource = "Cdn"
)

func PossibleCertificateSourceValues 

func PossibleCertificateSourceValues() []CertificateSource

PossibleCertificateSourceValues returns the possible values for the CertificateSource const type.

type CertificateSourceParameters 

type CertificateSourceParameters struct {
	// REQUIRED; Type of certificate used
	CertificateType *CertificateType

	// REQUIRED
	TypeName *CdnCertificateSourceParametersTypeName
}

CertificateSourceParameters - Defines the parameters for using CDN managed certificate for securing custom domain.

func (CertificateSourceParameters) MarshalJSON 

func (c CertificateSourceParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CertificateSourceParameters.

func (*CertificateSourceParameters) UnmarshalJSON 

func (c *CertificateSourceParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CertificateSourceParameters.

type CertificateType 

type CertificateType string

CertificateType - Type of certificate used 

const (
	CertificateTypeDedicated CertificateType = "Dedicated"
	CertificateTypeShared    CertificateType = "Shared"
)

func PossibleCertificateTypeValues 

func PossibleCertificateTypeValues() []CertificateType

PossibleCertificateTypeValues returns the possible values for the CertificateType const type.

type CheckEndpointNameAvailabilityInput 

type CheckEndpointNameAvailabilityInput struct {
	// REQUIRED; The resource name to validate.
	Name *string

	// REQUIRED; The type of the resource whose name is to be validated.
	Type *ResourceType

	// Indicates the endpoint name reuse scope. The default value is TenantReuse.
	AutoGeneratedDomainNameLabelScope *AutoGeneratedDomainNameLabelScope
}

CheckEndpointNameAvailabilityInput - Input of CheckNameAvailability API.

func (CheckEndpointNameAvailabilityInput) MarshalJSON 

func (c CheckEndpointNameAvailabilityInput) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CheckEndpointNameAvailabilityInput.

func (*CheckEndpointNameAvailabilityInput) UnmarshalJSON 

func (c *CheckEndpointNameAvailabilityInput) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CheckEndpointNameAvailabilityInput.

type CheckEndpointNameAvailabilityOutput 

type CheckEndpointNameAvailabilityOutput struct {
	// READ-ONLY; Returns the available hostname generated based on the AutoGeneratedDomainNameLabelScope when the name is available,
	// otherwise it returns empty string
	AvailableHostname *string

	// READ-ONLY; The detailed error message describing why the name is not available.
	Message *string

	// READ-ONLY; Indicates whether the name is available.
	NameAvailable *bool

	// READ-ONLY; The reason why the name is not available.
	Reason *string
}

CheckEndpointNameAvailabilityOutput - Output of check name availability API.

func (CheckEndpointNameAvailabilityOutput) MarshalJSON 

func (c CheckEndpointNameAvailabilityOutput) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CheckEndpointNameAvailabilityOutput.

func (*CheckEndpointNameAvailabilityOutput) UnmarshalJSON 

func (c *CheckEndpointNameAvailabilityOutput) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CheckEndpointNameAvailabilityOutput.

type CheckHostNameAvailabilityInput 

type CheckHostNameAvailabilityInput struct {
	// REQUIRED; The host name to validate.
	HostName *string
}

CheckHostNameAvailabilityInput - Input of CheckHostNameAvailability API.

func (CheckHostNameAvailabilityInput) MarshalJSON 

func (c CheckHostNameAvailabilityInput) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CheckHostNameAvailabilityInput.

func (*CheckHostNameAvailabilityInput) UnmarshalJSON 

func (c *CheckHostNameAvailabilityInput) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CheckHostNameAvailabilityInput.

type CheckNameAvailabilityInput 

type CheckNameAvailabilityInput struct {
	// REQUIRED; The resource name to validate.
	Name *string

	// REQUIRED; The type of the resource whose name is to be validated.
	Type *ResourceType
}

CheckNameAvailabilityInput - Input of CheckNameAvailability API.

func (CheckNameAvailabilityInput) MarshalJSON 

func (c CheckNameAvailabilityInput) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CheckNameAvailabilityInput.

func (*CheckNameAvailabilityInput) UnmarshalJSON 

func (c *CheckNameAvailabilityInput) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CheckNameAvailabilityInput.

type CheckNameAvailabilityOutput 

type CheckNameAvailabilityOutput struct {
	// READ-ONLY; The detailed error message describing why the name is not available.
	Message *string

	// READ-ONLY; Indicates whether the name is available.
	NameAvailable *bool

	// READ-ONLY; The reason why the name is not available.
	Reason *string
}

CheckNameAvailabilityOutput - Output of check name availability API.

func (CheckNameAvailabilityOutput) MarshalJSON 

func (c CheckNameAvailabilityOutput) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CheckNameAvailabilityOutput.

func (*CheckNameAvailabilityOutput) UnmarshalJSON 

func (c *CheckNameAvailabilityOutput) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CheckNameAvailabilityOutput.

type CidrIPAddress 

type CidrIPAddress struct {
	// Ip address itself.
	BaseIPAddress *string

	// The length of the prefix of the ip address.
	PrefixLength *int32
}

CidrIPAddress - CIDR Ip address

func (CidrIPAddress) MarshalJSON 

func (c CidrIPAddress) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CidrIPAddress.

func (*CidrIPAddress) UnmarshalJSON 

func (c *CidrIPAddress) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CidrIPAddress.

type ClientFactory 

type ClientFactory struct {
	// contains filtered or unexported fields
}

ClientFactory is a client factory used to create any client in this module. Don't use this type directly, use NewClientFactory instead.

func NewClientFactory 

func NewClientFactory(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ClientFactory, error)

NewClientFactory creates a new instance of ClientFactory with the specified values. The parameter values will be propagated to any client created from this factory.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewAFDCustomDomainsClient 

func (c *ClientFactory) NewAFDCustomDomainsClient() *AFDCustomDomainsClient

NewAFDCustomDomainsClient creates a new instance of AFDCustomDomainsClient.

func (*ClientFactory) NewAFDEndpointsClient 

func (c *ClientFactory) NewAFDEndpointsClient() *AFDEndpointsClient

NewAFDEndpointsClient creates a new instance of AFDEndpointsClient.

func (*ClientFactory) NewAFDOriginGroupsClient 

func (c *ClientFactory) NewAFDOriginGroupsClient() *AFDOriginGroupsClient

NewAFDOriginGroupsClient creates a new instance of AFDOriginGroupsClient.

func (*ClientFactory) NewAFDOriginsClient 

func (c *ClientFactory) NewAFDOriginsClient() *AFDOriginsClient

NewAFDOriginsClient creates a new instance of AFDOriginsClient.

func (*ClientFactory) NewAFDProfilesClient 

func (c *ClientFactory) NewAFDProfilesClient() *AFDProfilesClient

NewAFDProfilesClient creates a new instance of AFDProfilesClient.

func (*ClientFactory) NewCustomDomainsClient 

func (c *ClientFactory) NewCustomDomainsClient() *CustomDomainsClient

NewCustomDomainsClient creates a new instance of CustomDomainsClient.

func (*ClientFactory) NewEdgeNodesClient 

func (c *ClientFactory) NewEdgeNodesClient() *EdgeNodesClient

NewEdgeNodesClient creates a new instance of EdgeNodesClient.

func (*ClientFactory) NewEndpointsClient 

func (c *ClientFactory) NewEndpointsClient() *EndpointsClient

NewEndpointsClient creates a new instance of EndpointsClient.

func (*ClientFactory) NewLogAnalyticsClient 

func (c *ClientFactory) NewLogAnalyticsClient() *LogAnalyticsClient

NewLogAnalyticsClient creates a new instance of LogAnalyticsClient.

func (*ClientFactory) NewManagedRuleSetsClient 

func (c *ClientFactory) NewManagedRuleSetsClient() *ManagedRuleSetsClient

NewManagedRuleSetsClient creates a new instance of ManagedRuleSetsClient.

func (*ClientFactory) NewManagementClient 

func (c *ClientFactory) NewManagementClient() *ManagementClient

NewManagementClient creates a new instance of ManagementClient.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewOriginGroupsClient 

func (c *ClientFactory) NewOriginGroupsClient() *OriginGroupsClient

NewOriginGroupsClient creates a new instance of OriginGroupsClient.

func (*ClientFactory) NewOriginsClient 

func (c *ClientFactory) NewOriginsClient() *OriginsClient

NewOriginsClient creates a new instance of OriginsClient.

func (*ClientFactory) NewPoliciesClient 

func (c *ClientFactory) NewPoliciesClient() *PoliciesClient

NewPoliciesClient creates a new instance of PoliciesClient.

func (*ClientFactory) NewProfilesClient 

func (c *ClientFactory) NewProfilesClient() *ProfilesClient

NewProfilesClient creates a new instance of ProfilesClient.

func (*ClientFactory) NewResourceUsageClient 

func (c *ClientFactory) NewResourceUsageClient() *ResourceUsageClient

NewResourceUsageClient creates a new instance of ResourceUsageClient.

func (*ClientFactory) NewRoutesClient 

func (c *ClientFactory) NewRoutesClient() *RoutesClient

NewRoutesClient creates a new instance of RoutesClient.

func (*ClientFactory) NewRuleSetsClient 

func (c *ClientFactory) NewRuleSetsClient() *RuleSetsClient

NewRuleSetsClient creates a new instance of RuleSetsClient.

func (*ClientFactory) NewRulesClient 

func (c *ClientFactory) NewRulesClient() *RulesClient

NewRulesClient creates a new instance of RulesClient.

func (*ClientFactory) NewSecretsClient 

func (c *ClientFactory) NewSecretsClient() *SecretsClient

NewSecretsClient creates a new instance of SecretsClient.

func (*ClientFactory) NewSecurityPoliciesClient 

func (c *ClientFactory) NewSecurityPoliciesClient() *SecurityPoliciesClient

NewSecurityPoliciesClient creates a new instance of SecurityPoliciesClient.

type ClientPortMatchConditionParameters 

type ClientPortMatchConditionParameters struct {
	// REQUIRED; Describes operator to be matched
	Operator *ClientPortOperator

	// REQUIRED
	TypeName *ClientPortMatchConditionParametersTypeName

	// The match value for the condition of the delivery rule
	MatchValues []*string

	// Describes if this is negate condition or not
	NegateCondition *bool

	// List of transforms
	Transforms []*Transform
}

ClientPortMatchConditionParameters - Defines the parameters for ClientPort match conditions

func (ClientPortMatchConditionParameters) MarshalJSON 

func (c ClientPortMatchConditionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ClientPortMatchConditionParameters.

func (*ClientPortMatchConditionParameters) UnmarshalJSON 

func (c *ClientPortMatchConditionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ClientPortMatchConditionParameters.

type ClientPortMatchConditionParametersTypeName 

type ClientPortMatchConditionParametersTypeName string
const (
	ClientPortMatchConditionParametersTypeNameDeliveryRuleClientPortConditionParameters ClientPortMatchConditionParametersTypeName = "DeliveryRuleClientPortConditionParameters"
)

func PossibleClientPortMatchConditionParametersTypeNameValues 

func PossibleClientPortMatchConditionParametersTypeNameValues() []ClientPortMatchConditionParametersTypeName

PossibleClientPortMatchConditionParametersTypeNameValues returns the possible values for the ClientPortMatchConditionParametersTypeName const type.

type ClientPortOperator 

type ClientPortOperator string

ClientPortOperator - Describes operator to be matched 

const (
	ClientPortOperatorAny                ClientPortOperator = "Any"
	ClientPortOperatorBeginsWith         ClientPortOperator = "BeginsWith"
	ClientPortOperatorContains           ClientPortOperator = "Contains"
	ClientPortOperatorEndsWith           ClientPortOperator = "EndsWith"
	ClientPortOperatorEqual              ClientPortOperator = "Equal"
	ClientPortOperatorGreaterThan        ClientPortOperator = "GreaterThan"
	ClientPortOperatorGreaterThanOrEqual ClientPortOperator = "GreaterThanOrEqual"
	ClientPortOperatorLessThan           ClientPortOperator = "LessThan"
	ClientPortOperatorLessThanOrEqual    ClientPortOperator = "LessThanOrEqual"
	ClientPortOperatorRegEx              ClientPortOperator = "RegEx"
)

func PossibleClientPortOperatorValues 

func PossibleClientPortOperatorValues() []ClientPortOperator

PossibleClientPortOperatorValues returns the possible values for the ClientPortOperator const type.

type Components18OrqelSchemasWafmetricsresponsePropertiesSeriesItemsPropertiesDataItems 

type Components18OrqelSchemasWafmetricsresponsePropertiesSeriesItemsPropertiesDataItems struct {
	DateTime *time.Time
	Value    *float32
}

func (Components18OrqelSchemasWafmetricsresponsePropertiesSeriesItemsPropertiesDataItems) MarshalJSON 

func (c Components18OrqelSchemasWafmetricsresponsePropertiesSeriesItemsPropertiesDataItems) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Components18OrqelSchemasWafmetricsresponsePropertiesSeriesItemsPropertiesDataItems.

func (*Components18OrqelSchemasWafmetricsresponsePropertiesSeriesItemsPropertiesDataItems) UnmarshalJSON 

func (c *Components18OrqelSchemasWafmetricsresponsePropertiesSeriesItemsPropertiesDataItems) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Components18OrqelSchemasWafmetricsresponsePropertiesSeriesItemsPropertiesDataItems.

type Components1Gs0LlpSchemasMetricsresponsePropertiesSeriesItemsPropertiesDataItems 

type Components1Gs0LlpSchemasMetricsresponsePropertiesSeriesItemsPropertiesDataItems struct {
	DateTime *time.Time
	Value    *float32
}

func (Components1Gs0LlpSchemasMetricsresponsePropertiesSeriesItemsPropertiesDataItems) MarshalJSON 

func (c Components1Gs0LlpSchemasMetricsresponsePropertiesSeriesItemsPropertiesDataItems) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Components1Gs0LlpSchemasMetricsresponsePropertiesSeriesItemsPropertiesDataItems.

func (*Components1Gs0LlpSchemasMetricsresponsePropertiesSeriesItemsPropertiesDataItems) UnmarshalJSON 

func (c *Components1Gs0LlpSchemasMetricsresponsePropertiesSeriesItemsPropertiesDataItems) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Components1Gs0LlpSchemasMetricsresponsePropertiesSeriesItemsPropertiesDataItems.

type ComponentsKpo1PjSchemasWafrankingsresponsePropertiesDataItemsPropertiesMetricsItems 

type ComponentsKpo1PjSchemasWafrankingsresponsePropertiesDataItemsPropertiesMetricsItems struct {
	Metric     *string
	Percentage *float64
	Value      *int64
}

func (ComponentsKpo1PjSchemasWafrankingsresponsePropertiesDataItemsPropertiesMetricsItems) MarshalJSON 

func (c ComponentsKpo1PjSchemasWafrankingsresponsePropertiesDataItemsPropertiesMetricsItems) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ComponentsKpo1PjSchemasWafrankingsresponsePropertiesDataItemsPropertiesMetricsItems.

func (*ComponentsKpo1PjSchemasWafrankingsresponsePropertiesDataItemsPropertiesMetricsItems) UnmarshalJSON 

func (c *ComponentsKpo1PjSchemasWafrankingsresponsePropertiesDataItemsPropertiesMetricsItems) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ComponentsKpo1PjSchemasWafrankingsresponsePropertiesDataItemsPropertiesMetricsItems.

type CompressionSettings 

type CompressionSettings struct {
	// List of content types on which compression applies. The value should be a valid MIME type.
	ContentTypesToCompress []*string

	// Indicates whether content compression is enabled on AzureFrontDoor. Default value is false. If compression is enabled,
	// content will be served as compressed if user requests for a compressed version.
	// Content won't be compressed on AzureFrontDoor when requested content is smaller than 1 byte or larger than 1 MB.
	IsCompressionEnabled *bool
}

CompressionSettings - settings for compression.

func (CompressionSettings) MarshalJSON 

func (c CompressionSettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CompressionSettings.

func (*CompressionSettings) UnmarshalJSON 

func (c *CompressionSettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CompressionSettings.

type ContinentsResponse 

type ContinentsResponse struct {
	Continents       []*ContinentsResponseContinentsItem
	CountryOrRegions []*ContinentsResponseCountryOrRegionsItem
}

ContinentsResponse - Continents Response

func (ContinentsResponse) MarshalJSON 

func (c ContinentsResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ContinentsResponse.

func (*ContinentsResponse) UnmarshalJSON 

func (c *ContinentsResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ContinentsResponse.

type ContinentsResponseContinentsItem 

type ContinentsResponseContinentsItem struct {
	ID *string
}

func (ContinentsResponseContinentsItem) MarshalJSON 

func (c ContinentsResponseContinentsItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ContinentsResponseContinentsItem.

func (*ContinentsResponseContinentsItem) UnmarshalJSON 

func (c *ContinentsResponseContinentsItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ContinentsResponseContinentsItem.

type ContinentsResponseCountryOrRegionsItem 

type ContinentsResponseCountryOrRegionsItem struct {
	ContinentID *string
	ID          *string
}

func (ContinentsResponseCountryOrRegionsItem) MarshalJSON 

func (c ContinentsResponseCountryOrRegionsItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ContinentsResponseCountryOrRegionsItem.

func (*ContinentsResponseCountryOrRegionsItem) UnmarshalJSON 

func (c *ContinentsResponseCountryOrRegionsItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ContinentsResponseCountryOrRegionsItem.

type CookiesMatchConditionParameters 

type CookiesMatchConditionParameters struct {
	// REQUIRED; Describes operator to be matched
	Operator *CookiesOperator

	// REQUIRED
	TypeName *CookiesMatchConditionParametersTypeName

	// The match value for the condition of the delivery rule
	MatchValues []*string

	// Describes if this is negate condition or not
	NegateCondition *bool

	// Name of Cookies to be matched
	Selector *string

	// List of transforms
	Transforms []*Transform
}

CookiesMatchConditionParameters - Defines the parameters for Cookies match conditions

func (CookiesMatchConditionParameters) MarshalJSON 

func (c CookiesMatchConditionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CookiesMatchConditionParameters.

func (*CookiesMatchConditionParameters) UnmarshalJSON 

func (c *CookiesMatchConditionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CookiesMatchConditionParameters.

type CookiesMatchConditionParametersTypeName 

type CookiesMatchConditionParametersTypeName string
const (
	CookiesMatchConditionParametersTypeNameDeliveryRuleCookiesConditionParameters CookiesMatchConditionParametersTypeName = "DeliveryRuleCookiesConditionParameters"
)

func PossibleCookiesMatchConditionParametersTypeNameValues 

func PossibleCookiesMatchConditionParametersTypeNameValues() []CookiesMatchConditionParametersTypeName

PossibleCookiesMatchConditionParametersTypeNameValues returns the possible values for the CookiesMatchConditionParametersTypeName const type.

type CookiesOperator 

type CookiesOperator string

CookiesOperator - Describes operator to be matched 

const (
	CookiesOperatorAny                CookiesOperator = "Any"
	CookiesOperatorBeginsWith         CookiesOperator = "BeginsWith"
	CookiesOperatorContains           CookiesOperator = "Contains"
	CookiesOperatorEndsWith           CookiesOperator = "EndsWith"
	CookiesOperatorEqual              CookiesOperator = "Equal"
	CookiesOperatorGreaterThan        CookiesOperator = "GreaterThan"
	CookiesOperatorGreaterThanOrEqual CookiesOperator = "GreaterThanOrEqual"
	CookiesOperatorLessThan           CookiesOperator = "LessThan"
	CookiesOperatorLessThanOrEqual    CookiesOperator = "LessThanOrEqual"
	CookiesOperatorRegEx              CookiesOperator = "RegEx"
)

func PossibleCookiesOperatorValues 

func PossibleCookiesOperatorValues() []CookiesOperator

PossibleCookiesOperatorValues returns the possible values for the CookiesOperator const type.

type CustomDomain 

type CustomDomain struct {
	// The JSON object that contains the properties of the custom domain to create.
	Properties *CustomDomainProperties

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Read only system data
	SystemData *SystemData

	// READ-ONLY; Resource type.
	Type *string
}

CustomDomain - Friendly domain name mapping to the endpoint hostname that the customer provides for branding purposes, e.g. www.contoso.com.

func (CustomDomain) MarshalJSON 

func (c CustomDomain) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CustomDomain.

func (*CustomDomain) UnmarshalJSON 

func (c *CustomDomain) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CustomDomain.

type CustomDomainHTTPSParameters 

type CustomDomainHTTPSParameters struct {
	// REQUIRED; Defines the source of the SSL certificate.
	CertificateSource *CertificateSource

	// REQUIRED; Defines the TLS extension protocol that is used for secure delivery.
	ProtocolType *ProtocolType

	// TLS protocol version that will be used for Https
	MinimumTLSVersion *MinimumTLSVersion
}

CustomDomainHTTPSParameters - The JSON object that contains the properties to secure a custom domain.

func (*CustomDomainHTTPSParameters) GetCustomDomainHTTPSParameters 

func (c *CustomDomainHTTPSParameters) GetCustomDomainHTTPSParameters() *CustomDomainHTTPSParameters

GetCustomDomainHTTPSParameters implements the CustomDomainHTTPSParametersClassification interface for type CustomDomainHTTPSParameters.

func (CustomDomainHTTPSParameters) MarshalJSON 

func (c CustomDomainHTTPSParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CustomDomainHTTPSParameters.

func (*CustomDomainHTTPSParameters) UnmarshalJSON 

func (c *CustomDomainHTTPSParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CustomDomainHTTPSParameters.

type CustomDomainHTTPSParametersClassification 

type CustomDomainHTTPSParametersClassification interface {
	// GetCustomDomainHTTPSParameters returns the CustomDomainHTTPSParameters content of the underlying type.
	GetCustomDomainHTTPSParameters() *CustomDomainHTTPSParameters
}

CustomDomainHTTPSParametersClassification provides polymorphic access to related types. Call the interface's GetCustomDomainHTTPSParameters() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *CustomDomainHTTPSParameters, *ManagedHTTPSParameters, *UserManagedHTTPSParameters

type CustomDomainListResult 

type CustomDomainListResult struct {
	// URL to get the next set of custom domain objects if there are any.
	NextLink *string

	// READ-ONLY; List of CDN CustomDomains within an endpoint.
	Value []*CustomDomain
}

CustomDomainListResult - Result of the request to list custom domains. It contains a list of custom domain objects and a URL link to get the next set of results.

func (CustomDomainListResult) MarshalJSON 

func (c CustomDomainListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CustomDomainListResult.

func (*CustomDomainListResult) UnmarshalJSON 

func (c *CustomDomainListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CustomDomainListResult.

type CustomDomainParameters 

type CustomDomainParameters struct {
	// The JSON object that contains the properties of the custom domain to create.
	Properties *CustomDomainPropertiesParameters
}

CustomDomainParameters - The customDomain JSON object required for custom domain creation or update.

func (CustomDomainParameters) MarshalJSON 

func (c CustomDomainParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CustomDomainParameters.

func (*CustomDomainParameters) UnmarshalJSON 

func (c *CustomDomainParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CustomDomainParameters.

type CustomDomainProperties 

type CustomDomainProperties struct {
	// REQUIRED; The host name of the custom domain. Must be a domain name.
	HostName *string

	// Certificate parameters for securing custom HTTPS
	CustomHTTPSParameters CustomDomainHTTPSParametersClassification

	// Special validation or data may be required when delivering CDN to some regions due to local compliance reasons. E.g. ICP
	// license number of a custom domain is required to deliver content in China.
	ValidationData *string

	// READ-ONLY; Provisioning status of the custom domain.
	CustomHTTPSProvisioningState *CustomHTTPSProvisioningState

	// READ-ONLY; Provisioning substate shows the progress of custom HTTPS enabling/disabling process step by step.
	CustomHTTPSProvisioningSubstate *CustomHTTPSProvisioningSubstate

	// READ-ONLY; Provisioning status of Custom Https of the custom domain.
	ProvisioningState *CustomHTTPSProvisioningState

	// READ-ONLY; Resource status of the custom domain.
	ResourceState *CustomDomainResourceState
}

CustomDomainProperties - The JSON object that contains the properties of the custom domain to create.

func (CustomDomainProperties) MarshalJSON 

func (c CustomDomainProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CustomDomainProperties.

func (*CustomDomainProperties) UnmarshalJSON 

func (c *CustomDomainProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CustomDomainProperties.

type CustomDomainPropertiesParameters 

type CustomDomainPropertiesParameters struct {
	// REQUIRED; The host name of the custom domain. Must be a domain name.
	HostName *string
}

CustomDomainPropertiesParameters - The JSON object that contains the properties of the custom domain to create.

func (CustomDomainPropertiesParameters) MarshalJSON 

func (c CustomDomainPropertiesParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CustomDomainPropertiesParameters.

func (*CustomDomainPropertiesParameters) UnmarshalJSON 

func (c *CustomDomainPropertiesParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CustomDomainPropertiesParameters.

type CustomDomainResourceState 

type CustomDomainResourceState string

CustomDomainResourceState - Resource status of the custom domain. 

const (
	CustomDomainResourceStateActive   CustomDomainResourceState = "Active"
	CustomDomainResourceStateCreating CustomDomainResourceState = "Creating"
	CustomDomainResourceStateDeleting CustomDomainResourceState = "Deleting"
)

func PossibleCustomDomainResourceStateValues 

func PossibleCustomDomainResourceStateValues() []CustomDomainResourceState

PossibleCustomDomainResourceStateValues returns the possible values for the CustomDomainResourceState const type.

type CustomDomainsClient 

type CustomDomainsClient struct {
	// contains filtered or unexported fields
}

CustomDomainsClient contains the methods for the CustomDomains group. Don't use this type directly, use NewCustomDomainsClient() instead.

func NewCustomDomainsClient 

func NewCustomDomainsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*CustomDomainsClient, error)

NewCustomDomainsClient creates a new instance of CustomDomainsClient with the specified values.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*CustomDomainsClient) BeginCreate 

func (client *CustomDomainsClient) BeginCreate(ctx context.Context, resourceGroupName string, profileName string, endpointName string, customDomainName string, customDomainProperties CustomDomainParameters, options *CustomDomainsClientBeginCreateOptions) (*runtime.Poller[CustomDomainsClientCreateResponse], error)

BeginCreate - Creates a new custom domain within an endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • customDomainName - Name of the custom domain within an endpoint.
  • customDomainProperties - Properties required to create a new custom domain.
  • options - CustomDomainsClientBeginCreateOptions contains the optional parameters for the CustomDomainsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/CustomDomains_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewCustomDomainsClient().BeginCreate(ctx, "RG", "profile1", "endpoint1", "www-someDomain-net", armcdn.CustomDomainParameters{
	Properties: &armcdn.CustomDomainPropertiesParameters{
		HostName: to.Ptr("www.someDomain.net"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.CustomDomain = armcdn.CustomDomain{
// 	Name: to.Ptr("www-someDomain-net"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/endpoints/customdomains"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/customdomains/www-someDomain-net"),
// 	Properties: &armcdn.CustomDomainProperties{
// 		CustomHTTPSProvisioningState: to.Ptr(armcdn.CustomHTTPSProvisioningStateEnabling),
// 		CustomHTTPSProvisioningSubstate: to.Ptr(armcdn.CustomHTTPSProvisioningSubstatePendingDomainControlValidationREquestApproval),
// 		HostName: to.Ptr("www.someDomain.net"),
// 		ProvisioningState: to.Ptr(armcdn.CustomHTTPSProvisioningState("Succeeded")),
// 		ResourceState: to.Ptr(armcdn.CustomDomainResourceStateActive),
// 	},
// }

Output:

func (*CustomDomainsClient) BeginDelete 

func (client *CustomDomainsClient) BeginDelete(ctx context.Context, resourceGroupName string, profileName string, endpointName string, customDomainName string, options *CustomDomainsClientBeginDeleteOptions) (*runtime.Poller[CustomDomainsClientDeleteResponse], error)

BeginDelete - Deletes an existing custom domain within an endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • customDomainName - Name of the custom domain within an endpoint.
  • options - CustomDomainsClientBeginDeleteOptions contains the optional parameters for the CustomDomainsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/CustomDomains_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewCustomDomainsClient().BeginDelete(ctx, "RG", "profile1", "endpoint1", "www-someDomain-net", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*CustomDomainsClient) BeginDisableCustomHTTPS 

func (client *CustomDomainsClient) BeginDisableCustomHTTPS(ctx context.Context, resourceGroupName string, profileName string, endpointName string, customDomainName string, options *CustomDomainsClientBeginDisableCustomHTTPSOptions) (*runtime.Poller[CustomDomainsClientDisableCustomHTTPSResponse], error)

BeginDisableCustomHTTPS - Disable https delivery of the custom domain. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • customDomainName - Name of the custom domain within an endpoint.
  • options - CustomDomainsClientBeginDisableCustomHTTPSOptions contains the optional parameters for the CustomDomainsClient.BeginDisableCustomHTTPS method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/CustomDomains_DisableCustomHttps.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewCustomDomainsClient().BeginDisableCustomHTTPS(ctx, "RG", "profile1", "endpoint1", "www-someDomain-net", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.CustomDomain = armcdn.CustomDomain{
// 	Name: to.Ptr("www-someDomain-net"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/endpoints/customdomains"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/customdomains/www-someDomain-net"),
// 	Properties: &armcdn.CustomDomainProperties{
// 		CustomHTTPSProvisioningState: to.Ptr(armcdn.CustomHTTPSProvisioningStateDisabled),
// 		CustomHTTPSProvisioningSubstate: to.Ptr(armcdn.CustomHTTPSProvisioningSubstateCertificateDeleted),
// 		HostName: to.Ptr("www.someDomain.net"),
// 		ProvisioningState: to.Ptr(armcdn.CustomHTTPSProvisioningState("Succeeded")),
// 		ResourceState: to.Ptr(armcdn.CustomDomainResourceStateActive),
// 	},
// }

Output:

func (*CustomDomainsClient) BeginEnableCustomHTTPS 

func (client *CustomDomainsClient) BeginEnableCustomHTTPS(ctx context.Context, resourceGroupName string, profileName string, endpointName string, customDomainName string, options *CustomDomainsClientBeginEnableCustomHTTPSOptions) (*runtime.Poller[CustomDomainsClientEnableCustomHTTPSResponse], error)

BeginEnableCustomHTTPS - Enable https delivery of the custom domain. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • customDomainName - Name of the custom domain within an endpoint.
  • options - CustomDomainsClientBeginEnableCustomHTTPSOptions contains the optional parameters for the CustomDomainsClient.BeginEnableCustomHTTPS method.
Example (CustomDomainsEnableCustomHttpsUsingCdnManagedCertificate)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/CustomDomains_EnableCustomHttpsUsingCDNManagedCertificate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewCustomDomainsClient().BeginEnableCustomHTTPS(ctx, "RG", "profile1", "endpoint1", "www-someDomain-net", &armcdn.CustomDomainsClientBeginEnableCustomHTTPSOptions{CustomDomainHTTPSParameters: nil})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.CustomDomain = armcdn.CustomDomain{
// 	Name: to.Ptr("www-someDomain-net"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/endpoints/customdomains"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/customdomains/www-someDomain-net"),
// 	Properties: &armcdn.CustomDomainProperties{
// 		CustomHTTPSProvisioningState: to.Ptr(armcdn.CustomHTTPSProvisioningStateEnabled),
// 		CustomHTTPSProvisioningSubstate: to.Ptr(armcdn.CustomHTTPSProvisioningSubstateCertificateDeployed),
// 		HostName: to.Ptr("www.someDomain.net"),
// 		ProvisioningState: to.Ptr(armcdn.CustomHTTPSProvisioningState("Succeeded")),
// 		ResourceState: to.Ptr(armcdn.CustomDomainResourceStateActive),
// 		ValidationData: to.Ptr("validationdata"),
// 	},
// }

Output:
Example (CustomDomainsEnableCustomHttpsUsingYourOwnCertificate)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/CustomDomains_EnableCustomHttpsUsingBYOC.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewCustomDomainsClient().BeginEnableCustomHTTPS(ctx, "RG", "profile1", "endpoint1", "www-someDomain-net", &armcdn.CustomDomainsClientBeginEnableCustomHTTPSOptions{CustomDomainHTTPSParameters: nil})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.CustomDomain = armcdn.CustomDomain{
// 	Name: to.Ptr("www-someDomain-net"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/endpoints/customdomains"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/customdomains/www-someDomain-net"),
// 	Properties: &armcdn.CustomDomainProperties{
// 		CustomHTTPSProvisioningState: to.Ptr(armcdn.CustomHTTPSProvisioningStateEnabled),
// 		CustomHTTPSProvisioningSubstate: to.Ptr(armcdn.CustomHTTPSProvisioningSubstateCertificateDeployed),
// 		HostName: to.Ptr("www.someDomain.net"),
// 		ProvisioningState: to.Ptr(armcdn.CustomHTTPSProvisioningState("Succeeded")),
// 		ResourceState: to.Ptr(armcdn.CustomDomainResourceStateActive),
// 		ValidationData: to.Ptr("validationdata"),
// 	},
// }

Output:

func (*CustomDomainsClient) Get 

func (client *CustomDomainsClient) Get(ctx context.Context, resourceGroupName string, profileName string, endpointName string, customDomainName string, options *CustomDomainsClientGetOptions) (CustomDomainsClientGetResponse, error)

Get - Gets an existing custom domain within an endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • customDomainName - Name of the custom domain within an endpoint.
  • options - CustomDomainsClientGetOptions contains the optional parameters for the CustomDomainsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/CustomDomains_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewCustomDomainsClient().Get(ctx, "RG", "profile1", "endpoint1", "www-someDomain-net", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.CustomDomain = armcdn.CustomDomain{
// 	Name: to.Ptr("www-someDomain-net"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/endpoints/customdomains"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/customdomains/www-someDomain-net"),
// 	Properties: &armcdn.CustomDomainProperties{
// 		CustomHTTPSProvisioningState: to.Ptr(armcdn.CustomHTTPSProvisioningStateDisabled),
// 		CustomHTTPSProvisioningSubstate: to.Ptr(armcdn.CustomHTTPSProvisioningSubstate("None")),
// 		HostName: to.Ptr("www.someDomain.net"),
// 		ProvisioningState: to.Ptr(armcdn.CustomHTTPSProvisioningState("Succeeded")),
// 		ResourceState: to.Ptr(armcdn.CustomDomainResourceStateActive),
// 	},
// }

Output:

func (*CustomDomainsClient) NewListByEndpointPager 

func (client *CustomDomainsClient) NewListByEndpointPager(resourceGroupName string, profileName string, endpointName string, options *CustomDomainsClientListByEndpointOptions) *runtime.Pager[CustomDomainsClientListByEndpointResponse]

NewListByEndpointPager - Lists all of the existing custom domains within an endpoint.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • options - CustomDomainsClientListByEndpointOptions contains the optional parameters for the CustomDomainsClient.NewListByEndpointPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/CustomDomains_ListByEndpoint.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewCustomDomainsClient().NewListByEndpointPager("RG", "profile1", "endpoint1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.CustomDomainListResult = armcdn.CustomDomainListResult{
	// 	Value: []*armcdn.CustomDomain{
	// 		{
	// 			Name: to.Ptr("www-someDomain-net"),
	// 			Type: to.Ptr("Microsoft.Cdn/profiles/endpoints/customdomains"),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/customdomains/www-someDomain-net"),
	// 			Properties: &armcdn.CustomDomainProperties{
	// 				CustomHTTPSProvisioningState: to.Ptr(armcdn.CustomHTTPSProvisioningStateDisabled),
	// 				CustomHTTPSProvisioningSubstate: to.Ptr(armcdn.CustomHTTPSProvisioningSubstate("None")),
	// 				HostName: to.Ptr("www.someDomain.net"),
	// 				ProvisioningState: to.Ptr(armcdn.CustomHTTPSProvisioningState("Succeeded")),
	// 				ResourceState: to.Ptr(armcdn.CustomDomainResourceStateActive),
	// 			},
	// 	}},
	// }
}

Output:

type CustomDomainsClientBeginCreateOptions 

type CustomDomainsClientBeginCreateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

CustomDomainsClientBeginCreateOptions contains the optional parameters for the CustomDomainsClient.BeginCreate method.

type CustomDomainsClientBeginDeleteOptions 

type CustomDomainsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

CustomDomainsClientBeginDeleteOptions contains the optional parameters for the CustomDomainsClient.BeginDelete method.

type CustomDomainsClientBeginDisableCustomHTTPSOptions 

type CustomDomainsClientBeginDisableCustomHTTPSOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

CustomDomainsClientBeginDisableCustomHTTPSOptions contains the optional parameters for the CustomDomainsClient.BeginDisableCustomHTTPS method.

type CustomDomainsClientBeginEnableCustomHTTPSOptions 

type CustomDomainsClientBeginEnableCustomHTTPSOptions struct {
	// The configuration specifying how to enable HTTPS for the custom domain - using CDN managed certificate or user's own certificate.
	// If not specified, enabling ssl uses CDN managed certificate by
	// default.
	CustomDomainHTTPSParameters CustomDomainHTTPSParametersClassification

	// Resumes the LRO from the provided token.
	ResumeToken string
}

CustomDomainsClientBeginEnableCustomHTTPSOptions contains the optional parameters for the CustomDomainsClient.BeginEnableCustomHTTPS method.

type CustomDomainsClientCreateResponse 

type CustomDomainsClientCreateResponse struct {
	// Friendly domain name mapping to the endpoint hostname that the customer provides for branding purposes, e.g. www.contoso.com.
	CustomDomain
}

CustomDomainsClientCreateResponse contains the response from method CustomDomainsClient.BeginCreate.

type CustomDomainsClientDeleteResponse 

type CustomDomainsClientDeleteResponse struct {
	// Friendly domain name mapping to the endpoint hostname that the customer provides for branding purposes, e.g. www.contoso.com.
	CustomDomain
}

CustomDomainsClientDeleteResponse contains the response from method CustomDomainsClient.BeginDelete.

type CustomDomainsClientDisableCustomHTTPSResponse 

type CustomDomainsClientDisableCustomHTTPSResponse struct {
	// Friendly domain name mapping to the endpoint hostname that the customer provides for branding purposes, e.g. www.contoso.com.
	CustomDomain
}

CustomDomainsClientDisableCustomHTTPSResponse contains the response from method CustomDomainsClient.BeginDisableCustomHTTPS.

type CustomDomainsClientEnableCustomHTTPSResponse 

type CustomDomainsClientEnableCustomHTTPSResponse struct {
	// Friendly domain name mapping to the endpoint hostname that the customer provides for branding purposes, e.g. www.contoso.com.
	CustomDomain
}

CustomDomainsClientEnableCustomHTTPSResponse contains the response from method CustomDomainsClient.BeginEnableCustomHTTPS.

type CustomDomainsClientGetOptions 

type CustomDomainsClientGetOptions struct {
}

CustomDomainsClientGetOptions contains the optional parameters for the CustomDomainsClient.Get method.

type CustomDomainsClientGetResponse 

type CustomDomainsClientGetResponse struct {
	// Friendly domain name mapping to the endpoint hostname that the customer provides for branding purposes, e.g. www.contoso.com.
	CustomDomain
}

CustomDomainsClientGetResponse contains the response from method CustomDomainsClient.Get.

type CustomDomainsClientListByEndpointOptions 

type CustomDomainsClientListByEndpointOptions struct {
}

CustomDomainsClientListByEndpointOptions contains the optional parameters for the CustomDomainsClient.NewListByEndpointPager method.

type CustomDomainsClientListByEndpointResponse 

type CustomDomainsClientListByEndpointResponse struct {
	// Result of the request to list custom domains. It contains a list of custom domain objects and a URL link to get the next
	// set of results.
	CustomDomainListResult
}

CustomDomainsClientListByEndpointResponse contains the response from method CustomDomainsClient.NewListByEndpointPager.

type CustomHTTPSProvisioningState 

type CustomHTTPSProvisioningState string

CustomHTTPSProvisioningState - Provisioning status of the custom domain. 

const (
	CustomHTTPSProvisioningStateDisabled  CustomHTTPSProvisioningState = "Disabled"
	CustomHTTPSProvisioningStateDisabling CustomHTTPSProvisioningState = "Disabling"
	CustomHTTPSProvisioningStateEnabled   CustomHTTPSProvisioningState = "Enabled"
	CustomHTTPSProvisioningStateEnabling  CustomHTTPSProvisioningState = "Enabling"
	CustomHTTPSProvisioningStateFailed    CustomHTTPSProvisioningState = "Failed"
)

func PossibleCustomHTTPSProvisioningStateValues 

func PossibleCustomHTTPSProvisioningStateValues() []CustomHTTPSProvisioningState

PossibleCustomHTTPSProvisioningStateValues returns the possible values for the CustomHTTPSProvisioningState const type.

type CustomHTTPSProvisioningSubstate 

type CustomHTTPSProvisioningSubstate string

CustomHTTPSProvisioningSubstate - Provisioning substate shows the progress of custom HTTPS enabling/disabling process step by step. 

const (
	CustomHTTPSProvisioningSubstateCertificateDeleted                            CustomHTTPSProvisioningSubstate = "CertificateDeleted"
	CustomHTTPSProvisioningSubstateCertificateDeployed                           CustomHTTPSProvisioningSubstate = "CertificateDeployed"
	CustomHTTPSProvisioningSubstateDeletingCertificate                           CustomHTTPSProvisioningSubstate = "DeletingCertificate"
	CustomHTTPSProvisioningSubstateDeployingCertificate                          CustomHTTPSProvisioningSubstate = "DeployingCertificate"
	CustomHTTPSProvisioningSubstateDomainControlValidationRequestApproved        CustomHTTPSProvisioningSubstate = "DomainControlValidationRequestApproved"
	CustomHTTPSProvisioningSubstateDomainControlValidationRequestRejected        CustomHTTPSProvisioningSubstate = "DomainControlValidationRequestRejected"
	CustomHTTPSProvisioningSubstateDomainControlValidationRequestTimedOut        CustomHTTPSProvisioningSubstate = "DomainControlValidationRequestTimedOut"
	CustomHTTPSProvisioningSubstateIssuingCertificate                            CustomHTTPSProvisioningSubstate = "IssuingCertificate"
	CustomHTTPSProvisioningSubstatePendingDomainControlValidationREquestApproval CustomHTTPSProvisioningSubstate = "PendingDomainControlValidationREquestApproval"
	CustomHTTPSProvisioningSubstateSubmittingDomainControlValidationRequest      CustomHTTPSProvisioningSubstate = "SubmittingDomainControlValidationRequest"
)

func PossibleCustomHTTPSProvisioningSubstateValues 

func PossibleCustomHTTPSProvisioningSubstateValues() []CustomHTTPSProvisioningSubstate

PossibleCustomHTTPSProvisioningSubstateValues returns the possible values for the CustomHTTPSProvisioningSubstate const type.

type CustomRule 

type CustomRule struct {
	// REQUIRED; Describes what action to be applied when rule matches
	Action *ActionType

	// REQUIRED; List of match conditions.
	MatchConditions []*MatchCondition

	// REQUIRED; Defines the name of the custom rule
	Name *string

	// REQUIRED; Defines in what order this rule be evaluated in the overall list of custom rules
	Priority *int32

	// Describes if the custom rule is in enabled or disabled state. Defaults to Enabled if not specified.
	EnabledState *CustomRuleEnabledState
}

CustomRule - Defines the common attributes for a custom rule that can be included in a waf policy

func (CustomRule) MarshalJSON 

func (c CustomRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CustomRule.

func (*CustomRule) UnmarshalJSON 

func (c *CustomRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CustomRule.

type CustomRuleEnabledState 

type CustomRuleEnabledState string

CustomRuleEnabledState - Describes if the custom rule is in enabled or disabled state. Defaults to Enabled if not specified. 

const (
	CustomRuleEnabledStateDisabled CustomRuleEnabledState = "Disabled"
	CustomRuleEnabledStateEnabled  CustomRuleEnabledState = "Enabled"
)

func PossibleCustomRuleEnabledStateValues 

func PossibleCustomRuleEnabledStateValues() []CustomRuleEnabledState

PossibleCustomRuleEnabledStateValues returns the possible values for the CustomRuleEnabledState const type.

type CustomRuleList 

type CustomRuleList struct {
	// List of rules
	Rules []*CustomRule
}

CustomRuleList - Defines contents of custom rules

func (CustomRuleList) MarshalJSON 

func (c CustomRuleList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CustomRuleList.

func (*CustomRuleList) UnmarshalJSON 

func (c *CustomRuleList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CustomRuleList.

type CustomerCertificateParameters 

type CustomerCertificateParameters struct {
	// REQUIRED; Resource reference to the Azure Key Vault certificate. Expected to be in format of
	// /subscriptions/{​​​​​​​​​subscriptionId}​​​​​​​​​/resourceGroups/{​​​​​​​​​resourceGroupName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​/providers/Microsoft.KeyVault/vaults/{vaultName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​/secrets/{certificateName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​
	SecretSource *ResourceReference

	// REQUIRED; The type of the secret resource.
	Type *SecretType

	// Version of the secret to be used
	SecretVersion *string

	// The list of SANs.
	SubjectAlternativeNames []*string

	// Whether to use the latest version for the certificate
	UseLatestVersion *bool

	// READ-ONLY; Certificate issuing authority.
	CertificateAuthority *string

	// READ-ONLY; Certificate expiration date.
	ExpirationDate *string

	// READ-ONLY; Subject name in the certificate.
	Subject *string

	// READ-ONLY; Certificate thumbprint.
	Thumbprint *string
}

CustomerCertificateParameters - Customer Certificate used for https

func (*CustomerCertificateParameters) GetSecretParameters 

func (c *CustomerCertificateParameters) GetSecretParameters() *SecretParameters

GetSecretParameters implements the SecretParametersClassification interface for type CustomerCertificateParameters.

func (CustomerCertificateParameters) MarshalJSON 

func (c CustomerCertificateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CustomerCertificateParameters.

func (*CustomerCertificateParameters) UnmarshalJSON 

func (c *CustomerCertificateParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CustomerCertificateParameters.

type DeepCreatedCustomDomain 

type DeepCreatedCustomDomain struct {
	// REQUIRED; Custom domain name.
	Name *string

	// Properties of the custom domain created on the CDN endpoint.
	Properties *DeepCreatedCustomDomainProperties
}

DeepCreatedCustomDomain - Custom domains created on the CDN endpoint.

func (DeepCreatedCustomDomain) MarshalJSON 

func (d DeepCreatedCustomDomain) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeepCreatedCustomDomain.

func (*DeepCreatedCustomDomain) UnmarshalJSON 

func (d *DeepCreatedCustomDomain) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeepCreatedCustomDomain.

type DeepCreatedCustomDomainProperties 

type DeepCreatedCustomDomainProperties struct {
	// REQUIRED; The host name of the custom domain. Must be a domain name.
	HostName *string

	// Special validation or data may be required when delivering CDN to some regions due to local compliance reasons. E.g. ICP
	// license number of a custom domain is required to deliver content in China.
	ValidationData *string
}

DeepCreatedCustomDomainProperties - Properties of the custom domain created on the CDN endpoint.

func (DeepCreatedCustomDomainProperties) MarshalJSON 

func (d DeepCreatedCustomDomainProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeepCreatedCustomDomainProperties.

func (*DeepCreatedCustomDomainProperties) UnmarshalJSON 

func (d *DeepCreatedCustomDomainProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeepCreatedCustomDomainProperties.

type DeepCreatedOrigin 

type DeepCreatedOrigin struct {
	// REQUIRED; Origin name which must be unique within the endpoint.
	Name *string

	// Properties of the origin created on the CDN endpoint.
	Properties *DeepCreatedOriginProperties
}

DeepCreatedOrigin - The main origin of CDN content which is added when creating a CDN endpoint.

func (DeepCreatedOrigin) MarshalJSON 

func (d DeepCreatedOrigin) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeepCreatedOrigin.

func (*DeepCreatedOrigin) UnmarshalJSON 

func (d *DeepCreatedOrigin) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeepCreatedOrigin.

type DeepCreatedOriginGroup 

type DeepCreatedOriginGroup struct {
	// REQUIRED; Origin group name which must be unique within the endpoint.
	Name *string

	// Properties of the origin group created on the CDN endpoint.
	Properties *DeepCreatedOriginGroupProperties
}

DeepCreatedOriginGroup - The origin group for CDN content which is added when creating a CDN endpoint. Traffic is sent to the origins within the origin group based on origin health.

func (DeepCreatedOriginGroup) MarshalJSON 

func (d DeepCreatedOriginGroup) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeepCreatedOriginGroup.

func (*DeepCreatedOriginGroup) UnmarshalJSON 

func (d *DeepCreatedOriginGroup) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeepCreatedOriginGroup.

type DeepCreatedOriginGroupProperties 

type DeepCreatedOriginGroupProperties struct {
	// REQUIRED; The source of the content being delivered via CDN within given origin group.
	Origins []*ResourceReference

	// Health probe settings to the origin that is used to determine the health of the origin.
	HealthProbeSettings *HealthProbeParameters

	// The JSON object that contains the properties to determine origin health using real requests/responses.This property is
	// currently not supported.
	ResponseBasedOriginErrorDetectionSettings *ResponseBasedOriginErrorDetectionParameters

	// Time in minutes to shift the traffic to the endpoint gradually when an unhealthy endpoint comes healthy or a new endpoint
	// is added. Default is 10 mins. This property is currently not supported.
	TrafficRestorationTimeToHealedOrNewEndpointsInMinutes *int32
}

DeepCreatedOriginGroupProperties - Properties of the origin group created on the CDN endpoint.

func (DeepCreatedOriginGroupProperties) MarshalJSON 

func (d DeepCreatedOriginGroupProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeepCreatedOriginGroupProperties.

func (*DeepCreatedOriginGroupProperties) UnmarshalJSON 

func (d *DeepCreatedOriginGroupProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeepCreatedOriginGroupProperties.

type DeepCreatedOriginProperties 

type DeepCreatedOriginProperties struct {
	// REQUIRED; The address of the origin. It can be a domain name, IPv4 address, or IPv6 address. This should be unique across
	// all origins in an endpoint.
	HostName *string

	// Origin is enabled for load balancing or not. By default, origin is always enabled.
	Enabled *bool

	// The value of the HTTP port. Must be between 1 and 65535.
	HTTPPort *int32

	// The value of the HTTPS port. Must be between 1 and 65535.
	HTTPSPort *int32

	// The host header value sent to the origin with each request. If you leave this blank, the request hostname determines this
	// value. Azure CDN origins, such as Web Apps, Blob Storage, and Cloud Services
	// require this host header value to match the origin hostname by default.
	OriginHostHeader *string

	// Priority of origin in given origin group for load balancing. Higher priorities will not be used for load balancing if any
	// lower priority origin is healthy.Must be between 1 and 5.
	Priority *int32

	// The Alias of the Private Link resource. Populating this optional field indicates that this origin is 'Private'
	PrivateLinkAlias *string

	// A custom message to be included in the approval request to connect to the Private Link.
	PrivateLinkApprovalMessage *string

	// The location of the Private Link resource. Required only if 'privateLinkResourceId' is populated
	PrivateLinkLocation *string

	// The Resource Id of the Private Link resource. Populating this optional field indicates that this backend is 'Private'
	PrivateLinkResourceID *string

	// Weight of the origin in given origin group for load balancing. Must be between 1 and 1000
	Weight *int32

	// READ-ONLY; The approval status for the connection to the Private Link
	PrivateEndpointStatus *PrivateEndpointStatus
}

DeepCreatedOriginProperties - Properties of the origin created on the CDN endpoint.

func (DeepCreatedOriginProperties) MarshalJSON 

func (d DeepCreatedOriginProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeepCreatedOriginProperties.

func (*DeepCreatedOriginProperties) UnmarshalJSON 

func (d *DeepCreatedOriginProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeepCreatedOriginProperties.

type DeleteRule 

type DeleteRule string

DeleteRule - Describes the action that shall be taken when the certificate is removed from Key Vault. 

const (
	DeleteRuleNoAction DeleteRule = "NoAction"
)

func PossibleDeleteRuleValues 

func PossibleDeleteRuleValues() []DeleteRule

PossibleDeleteRuleValues returns the possible values for the DeleteRule const type.

type DeliveryRule 

type DeliveryRule struct {
	// REQUIRED; A list of actions that are executed when all the conditions of a rule are satisfied.
	Actions []DeliveryRuleActionAutoGeneratedClassification

	// REQUIRED; The order in which the rules are applied for the endpoint. Possible values {0,1,2,3,………}. A rule with a lesser
	// order will be applied before a rule with a greater order. Rule with order 0 is a special
	// rule. It does not require any condition and actions listed in it will always be applied.
	Order *int32

	// A list of conditions that must be matched for the actions to be executed
	Conditions []DeliveryRuleConditionClassification

	// Name of the rule
	Name *string
}

DeliveryRule - A rule that specifies a set of actions and conditions

func (DeliveryRule) MarshalJSON 

func (d DeliveryRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRule.

func (*DeliveryRule) UnmarshalJSON 

func (d *DeliveryRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRule.

type DeliveryRuleAction 

type DeliveryRuleAction string

DeliveryRuleAction - The name of the action for the delivery rule. 

const (
	DeliveryRuleActionCacheExpiration            DeliveryRuleAction = "CacheExpiration"
	DeliveryRuleActionCacheKeyQueryString        DeliveryRuleAction = "CacheKeyQueryString"
	DeliveryRuleActionModifyRequestHeader        DeliveryRuleAction = "ModifyRequestHeader"
	DeliveryRuleActionModifyResponseHeader       DeliveryRuleAction = "ModifyResponseHeader"
	DeliveryRuleActionOriginGroupOverride        DeliveryRuleAction = "OriginGroupOverride"
	DeliveryRuleActionRouteConfigurationOverride DeliveryRuleAction = "RouteConfigurationOverride"
	DeliveryRuleActionURLRedirect                DeliveryRuleAction = "UrlRedirect"
	DeliveryRuleActionURLRewrite                 DeliveryRuleAction = "UrlRewrite"
	DeliveryRuleActionURLSigning                 DeliveryRuleAction = "UrlSigning"
)

func PossibleDeliveryRuleActionValues 

func PossibleDeliveryRuleActionValues() []DeliveryRuleAction

PossibleDeliveryRuleActionValues returns the possible values for the DeliveryRuleAction const type.

type DeliveryRuleActionAutoGenerated 

type DeliveryRuleActionAutoGenerated struct {
	// REQUIRED; The name of the action for the delivery rule.
	Name *DeliveryRuleAction
}

DeliveryRuleActionAutoGenerated - An action for the delivery rule.

func (*DeliveryRuleActionAutoGenerated) GetDeliveryRuleActionAutoGenerated 

func (d *DeliveryRuleActionAutoGenerated) GetDeliveryRuleActionAutoGenerated() *DeliveryRuleActionAutoGenerated

GetDeliveryRuleActionAutoGenerated implements the DeliveryRuleActionAutoGeneratedClassification interface for type DeliveryRuleActionAutoGenerated.

func (DeliveryRuleActionAutoGenerated) MarshalJSON 

func (d DeliveryRuleActionAutoGenerated) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleActionAutoGenerated.

func (*DeliveryRuleActionAutoGenerated) UnmarshalJSON 

func (d *DeliveryRuleActionAutoGenerated) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleActionAutoGenerated.

type DeliveryRuleActionAutoGeneratedClassification 

type DeliveryRuleActionAutoGeneratedClassification interface {
	// GetDeliveryRuleActionAutoGenerated returns the DeliveryRuleActionAutoGenerated content of the underlying type.
	GetDeliveryRuleActionAutoGenerated() *DeliveryRuleActionAutoGenerated
}

DeliveryRuleActionAutoGeneratedClassification provides polymorphic access to related types. Call the interface's GetDeliveryRuleActionAutoGenerated() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *DeliveryRuleActionAutoGenerated, *DeliveryRuleCacheExpirationAction, *DeliveryRuleCacheKeyQueryStringAction, *DeliveryRuleRequestHeaderAction, - *DeliveryRuleResponseHeaderAction, *DeliveryRuleRouteConfigurationOverrideAction, *OriginGroupOverrideAction, *URLRedirectAction, - *URLRewriteAction, *URLSigningAction

type DeliveryRuleCacheExpirationAction 

type DeliveryRuleCacheExpirationAction struct {
	// REQUIRED; The name of the action for the delivery rule.
	Name *DeliveryRuleAction

	// REQUIRED; Defines the parameters for the action.
	Parameters *CacheExpirationActionParameters
}

DeliveryRuleCacheExpirationAction - Defines the cache expiration action for the delivery rule.

func (*DeliveryRuleCacheExpirationAction) GetDeliveryRuleActionAutoGenerated 

func (d *DeliveryRuleCacheExpirationAction) GetDeliveryRuleActionAutoGenerated() *DeliveryRuleActionAutoGenerated

GetDeliveryRuleActionAutoGenerated implements the DeliveryRuleActionAutoGeneratedClassification interface for type DeliveryRuleCacheExpirationAction.

func (DeliveryRuleCacheExpirationAction) MarshalJSON 

func (d DeliveryRuleCacheExpirationAction) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleCacheExpirationAction.

func (*DeliveryRuleCacheExpirationAction) UnmarshalJSON 

func (d *DeliveryRuleCacheExpirationAction) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleCacheExpirationAction.

type DeliveryRuleCacheKeyQueryStringAction 

type DeliveryRuleCacheKeyQueryStringAction struct {
	// REQUIRED; The name of the action for the delivery rule.
	Name *DeliveryRuleAction

	// REQUIRED; Defines the parameters for the action.
	Parameters *CacheKeyQueryStringActionParameters
}

DeliveryRuleCacheKeyQueryStringAction - Defines the cache-key query string action for the delivery rule.

func (*DeliveryRuleCacheKeyQueryStringAction) GetDeliveryRuleActionAutoGenerated 

func (d *DeliveryRuleCacheKeyQueryStringAction) GetDeliveryRuleActionAutoGenerated() *DeliveryRuleActionAutoGenerated

GetDeliveryRuleActionAutoGenerated implements the DeliveryRuleActionAutoGeneratedClassification interface for type DeliveryRuleCacheKeyQueryStringAction.

func (DeliveryRuleCacheKeyQueryStringAction) MarshalJSON 

func (d DeliveryRuleCacheKeyQueryStringAction) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleCacheKeyQueryStringAction.

func (*DeliveryRuleCacheKeyQueryStringAction) UnmarshalJSON 

func (d *DeliveryRuleCacheKeyQueryStringAction) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleCacheKeyQueryStringAction.

type DeliveryRuleClientPortCondition 

type DeliveryRuleClientPortCondition struct {
	// REQUIRED; The name of the condition for the delivery rule.
	Name *MatchVariable

	// REQUIRED; Defines the parameters for the condition.
	Parameters *ClientPortMatchConditionParameters
}

DeliveryRuleClientPortCondition - Defines the ClientPort condition for the delivery rule.

func (*DeliveryRuleClientPortCondition) GetDeliveryRuleCondition 

func (d *DeliveryRuleClientPortCondition) GetDeliveryRuleCondition() *DeliveryRuleCondition

GetDeliveryRuleCondition implements the DeliveryRuleConditionClassification interface for type DeliveryRuleClientPortCondition.

func (DeliveryRuleClientPortCondition) MarshalJSON 

func (d DeliveryRuleClientPortCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleClientPortCondition.

func (*DeliveryRuleClientPortCondition) UnmarshalJSON 

func (d *DeliveryRuleClientPortCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleClientPortCondition.

type DeliveryRuleCondition 

type DeliveryRuleCondition struct {
	// REQUIRED; The name of the condition for the delivery rule.
	Name *MatchVariable
}

DeliveryRuleCondition - A condition for the delivery rule.

func (*DeliveryRuleCondition) GetDeliveryRuleCondition 

func (d *DeliveryRuleCondition) GetDeliveryRuleCondition() *DeliveryRuleCondition

GetDeliveryRuleCondition implements the DeliveryRuleConditionClassification interface for type DeliveryRuleCondition.

func (DeliveryRuleCondition) MarshalJSON 

func (d DeliveryRuleCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleCondition.

func (*DeliveryRuleCondition) UnmarshalJSON 

func (d *DeliveryRuleCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleCondition.

type DeliveryRuleConditionClassification 

type DeliveryRuleConditionClassification interface {
	// GetDeliveryRuleCondition returns the DeliveryRuleCondition content of the underlying type.
	GetDeliveryRuleCondition() *DeliveryRuleCondition
}

DeliveryRuleConditionClassification provides polymorphic access to related types. Call the interface's GetDeliveryRuleCondition() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *DeliveryRuleClientPortCondition, *DeliveryRuleCondition, *DeliveryRuleCookiesCondition, *DeliveryRuleHTTPVersionCondition, - *DeliveryRuleHostNameCondition, *DeliveryRuleIsDeviceCondition, *DeliveryRulePostArgsCondition, *DeliveryRuleQueryStringCondition, - *DeliveryRuleRemoteAddressCondition, *DeliveryRuleRequestBodyCondition, *DeliveryRuleRequestHeaderCondition, *DeliveryRuleRequestMethodCondition, - *DeliveryRuleRequestSchemeCondition, *DeliveryRuleRequestURICondition, *DeliveryRuleSSLProtocolCondition, *DeliveryRuleServerPortCondition, - *DeliveryRuleSocketAddrCondition, *DeliveryRuleURLFileExtensionCondition, *DeliveryRuleURLFileNameCondition, *DeliveryRuleURLPathCondition

type DeliveryRuleCookiesCondition 

type DeliveryRuleCookiesCondition struct {
	// REQUIRED; The name of the condition for the delivery rule.
	Name *MatchVariable

	// REQUIRED; Defines the parameters for the condition.
	Parameters *CookiesMatchConditionParameters
}

DeliveryRuleCookiesCondition - Defines the Cookies condition for the delivery rule.

func (*DeliveryRuleCookiesCondition) GetDeliveryRuleCondition 

func (d *DeliveryRuleCookiesCondition) GetDeliveryRuleCondition() *DeliveryRuleCondition

GetDeliveryRuleCondition implements the DeliveryRuleConditionClassification interface for type DeliveryRuleCookiesCondition.

func (DeliveryRuleCookiesCondition) MarshalJSON 

func (d DeliveryRuleCookiesCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleCookiesCondition.

func (*DeliveryRuleCookiesCondition) UnmarshalJSON 

func (d *DeliveryRuleCookiesCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleCookiesCondition.

type DeliveryRuleHTTPVersionCondition 

type DeliveryRuleHTTPVersionCondition struct {
	// REQUIRED; The name of the condition for the delivery rule.
	Name *MatchVariable

	// REQUIRED; Defines the parameters for the condition.
	Parameters *HTTPVersionMatchConditionParameters
}

DeliveryRuleHTTPVersionCondition - Defines the HttpVersion condition for the delivery rule.

func (*DeliveryRuleHTTPVersionCondition) GetDeliveryRuleCondition 

func (d *DeliveryRuleHTTPVersionCondition) GetDeliveryRuleCondition() *DeliveryRuleCondition

GetDeliveryRuleCondition implements the DeliveryRuleConditionClassification interface for type DeliveryRuleHTTPVersionCondition.

func (DeliveryRuleHTTPVersionCondition) MarshalJSON 

func (d DeliveryRuleHTTPVersionCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleHTTPVersionCondition.

func (*DeliveryRuleHTTPVersionCondition) UnmarshalJSON 

func (d *DeliveryRuleHTTPVersionCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleHTTPVersionCondition.

type DeliveryRuleHostNameCondition 

type DeliveryRuleHostNameCondition struct {
	// REQUIRED; The name of the condition for the delivery rule.
	Name *MatchVariable

	// REQUIRED; Defines the parameters for the condition.
	Parameters *HostNameMatchConditionParameters
}

DeliveryRuleHostNameCondition - Defines the HostName condition for the delivery rule.

func (*DeliveryRuleHostNameCondition) GetDeliveryRuleCondition 

func (d *DeliveryRuleHostNameCondition) GetDeliveryRuleCondition() *DeliveryRuleCondition

GetDeliveryRuleCondition implements the DeliveryRuleConditionClassification interface for type DeliveryRuleHostNameCondition.

func (DeliveryRuleHostNameCondition) MarshalJSON 

func (d DeliveryRuleHostNameCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleHostNameCondition.

func (*DeliveryRuleHostNameCondition) UnmarshalJSON 

func (d *DeliveryRuleHostNameCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleHostNameCondition.

type DeliveryRuleIsDeviceCondition 

type DeliveryRuleIsDeviceCondition struct {
	// REQUIRED; The name of the condition for the delivery rule.
	Name *MatchVariable

	// REQUIRED; Defines the parameters for the condition.
	Parameters *IsDeviceMatchConditionParameters
}

DeliveryRuleIsDeviceCondition - Defines the IsDevice condition for the delivery rule.

func (*DeliveryRuleIsDeviceCondition) GetDeliveryRuleCondition 

func (d *DeliveryRuleIsDeviceCondition) GetDeliveryRuleCondition() *DeliveryRuleCondition

GetDeliveryRuleCondition implements the DeliveryRuleConditionClassification interface for type DeliveryRuleIsDeviceCondition.

func (DeliveryRuleIsDeviceCondition) MarshalJSON 

func (d DeliveryRuleIsDeviceCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleIsDeviceCondition.

func (*DeliveryRuleIsDeviceCondition) UnmarshalJSON 

func (d *DeliveryRuleIsDeviceCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleIsDeviceCondition.

type DeliveryRulePostArgsCondition 

type DeliveryRulePostArgsCondition struct {
	// REQUIRED; The name of the condition for the delivery rule.
	Name *MatchVariable

	// REQUIRED; Defines the parameters for the condition.
	Parameters *PostArgsMatchConditionParameters
}

DeliveryRulePostArgsCondition - Defines the PostArgs condition for the delivery rule.

func (*DeliveryRulePostArgsCondition) GetDeliveryRuleCondition 

func (d *DeliveryRulePostArgsCondition) GetDeliveryRuleCondition() *DeliveryRuleCondition

GetDeliveryRuleCondition implements the DeliveryRuleConditionClassification interface for type DeliveryRulePostArgsCondition.

func (DeliveryRulePostArgsCondition) MarshalJSON 

func (d DeliveryRulePostArgsCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRulePostArgsCondition.

func (*DeliveryRulePostArgsCondition) UnmarshalJSON 

func (d *DeliveryRulePostArgsCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRulePostArgsCondition.

type DeliveryRuleQueryStringCondition 

type DeliveryRuleQueryStringCondition struct {
	// REQUIRED; The name of the condition for the delivery rule.
	Name *MatchVariable

	// REQUIRED; Defines the parameters for the condition.
	Parameters *QueryStringMatchConditionParameters
}

DeliveryRuleQueryStringCondition - Defines the QueryString condition for the delivery rule.

func (*DeliveryRuleQueryStringCondition) GetDeliveryRuleCondition 

func (d *DeliveryRuleQueryStringCondition) GetDeliveryRuleCondition() *DeliveryRuleCondition

GetDeliveryRuleCondition implements the DeliveryRuleConditionClassification interface for type DeliveryRuleQueryStringCondition.

func (DeliveryRuleQueryStringCondition) MarshalJSON 

func (d DeliveryRuleQueryStringCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleQueryStringCondition.

func (*DeliveryRuleQueryStringCondition) UnmarshalJSON 

func (d *DeliveryRuleQueryStringCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleQueryStringCondition.

type DeliveryRuleRemoteAddressCondition 

type DeliveryRuleRemoteAddressCondition struct {
	// REQUIRED; The name of the condition for the delivery rule.
	Name *MatchVariable

	// REQUIRED; Defines the parameters for the condition.
	Parameters *RemoteAddressMatchConditionParameters
}

DeliveryRuleRemoteAddressCondition - Defines the RemoteAddress condition for the delivery rule.

func (*DeliveryRuleRemoteAddressCondition) GetDeliveryRuleCondition 

func (d *DeliveryRuleRemoteAddressCondition) GetDeliveryRuleCondition() *DeliveryRuleCondition

GetDeliveryRuleCondition implements the DeliveryRuleConditionClassification interface for type DeliveryRuleRemoteAddressCondition.

func (DeliveryRuleRemoteAddressCondition) MarshalJSON 

func (d DeliveryRuleRemoteAddressCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleRemoteAddressCondition.

func (*DeliveryRuleRemoteAddressCondition) UnmarshalJSON 

func (d *DeliveryRuleRemoteAddressCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleRemoteAddressCondition.

type DeliveryRuleRequestBodyCondition 

type DeliveryRuleRequestBodyCondition struct {
	// REQUIRED; The name of the condition for the delivery rule.
	Name *MatchVariable

	// REQUIRED; Defines the parameters for the condition.
	Parameters *RequestBodyMatchConditionParameters
}

DeliveryRuleRequestBodyCondition - Defines the RequestBody condition for the delivery rule.

func (*DeliveryRuleRequestBodyCondition) GetDeliveryRuleCondition 

func (d *DeliveryRuleRequestBodyCondition) GetDeliveryRuleCondition() *DeliveryRuleCondition

GetDeliveryRuleCondition implements the DeliveryRuleConditionClassification interface for type DeliveryRuleRequestBodyCondition.

func (DeliveryRuleRequestBodyCondition) MarshalJSON 

func (d DeliveryRuleRequestBodyCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleRequestBodyCondition.

func (*DeliveryRuleRequestBodyCondition) UnmarshalJSON 

func (d *DeliveryRuleRequestBodyCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleRequestBodyCondition.

type DeliveryRuleRequestHeaderAction 

type DeliveryRuleRequestHeaderAction struct {
	// REQUIRED; The name of the action for the delivery rule.
	Name *DeliveryRuleAction

	// REQUIRED; Defines the parameters for the action.
	Parameters *HeaderActionParameters
}

DeliveryRuleRequestHeaderAction - Defines the request header action for the delivery rule.

func (*DeliveryRuleRequestHeaderAction) GetDeliveryRuleActionAutoGenerated 

func (d *DeliveryRuleRequestHeaderAction) GetDeliveryRuleActionAutoGenerated() *DeliveryRuleActionAutoGenerated

GetDeliveryRuleActionAutoGenerated implements the DeliveryRuleActionAutoGeneratedClassification interface for type DeliveryRuleRequestHeaderAction.

func (DeliveryRuleRequestHeaderAction) MarshalJSON 

func (d DeliveryRuleRequestHeaderAction) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleRequestHeaderAction.

func (*DeliveryRuleRequestHeaderAction) UnmarshalJSON 

func (d *DeliveryRuleRequestHeaderAction) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleRequestHeaderAction.

type DeliveryRuleRequestHeaderCondition 

type DeliveryRuleRequestHeaderCondition struct {
	// REQUIRED; The name of the condition for the delivery rule.
	Name *MatchVariable

	// REQUIRED; Defines the parameters for the condition.
	Parameters *RequestHeaderMatchConditionParameters
}

DeliveryRuleRequestHeaderCondition - Defines the RequestHeader condition for the delivery rule.

func (*DeliveryRuleRequestHeaderCondition) GetDeliveryRuleCondition 

func (d *DeliveryRuleRequestHeaderCondition) GetDeliveryRuleCondition() *DeliveryRuleCondition

GetDeliveryRuleCondition implements the DeliveryRuleConditionClassification interface for type DeliveryRuleRequestHeaderCondition.

func (DeliveryRuleRequestHeaderCondition) MarshalJSON 

func (d DeliveryRuleRequestHeaderCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleRequestHeaderCondition.

func (*DeliveryRuleRequestHeaderCondition) UnmarshalJSON 

func (d *DeliveryRuleRequestHeaderCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleRequestHeaderCondition.

type DeliveryRuleRequestMethodCondition 

type DeliveryRuleRequestMethodCondition struct {
	// REQUIRED; The name of the condition for the delivery rule.
	Name *MatchVariable

	// REQUIRED; Defines the parameters for the condition.
	Parameters *RequestMethodMatchConditionParameters
}

DeliveryRuleRequestMethodCondition - Defines the RequestMethod condition for the delivery rule.

func (*DeliveryRuleRequestMethodCondition) GetDeliveryRuleCondition 

func (d *DeliveryRuleRequestMethodCondition) GetDeliveryRuleCondition() *DeliveryRuleCondition

GetDeliveryRuleCondition implements the DeliveryRuleConditionClassification interface for type DeliveryRuleRequestMethodCondition.

func (DeliveryRuleRequestMethodCondition) MarshalJSON 

func (d DeliveryRuleRequestMethodCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleRequestMethodCondition.

func (*DeliveryRuleRequestMethodCondition) UnmarshalJSON 

func (d *DeliveryRuleRequestMethodCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleRequestMethodCondition.

type DeliveryRuleRequestSchemeCondition 

type DeliveryRuleRequestSchemeCondition struct {
	// REQUIRED; The name of the condition for the delivery rule.
	Name *MatchVariable

	// REQUIRED; Defines the parameters for the condition.
	Parameters *RequestSchemeMatchConditionParameters
}

DeliveryRuleRequestSchemeCondition - Defines the RequestScheme condition for the delivery rule.

func (*DeliveryRuleRequestSchemeCondition) GetDeliveryRuleCondition 

func (d *DeliveryRuleRequestSchemeCondition) GetDeliveryRuleCondition() *DeliveryRuleCondition

GetDeliveryRuleCondition implements the DeliveryRuleConditionClassification interface for type DeliveryRuleRequestSchemeCondition.

func (DeliveryRuleRequestSchemeCondition) MarshalJSON 

func (d DeliveryRuleRequestSchemeCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleRequestSchemeCondition.

func (*DeliveryRuleRequestSchemeCondition) UnmarshalJSON 

func (d *DeliveryRuleRequestSchemeCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleRequestSchemeCondition.

type DeliveryRuleRequestURICondition 

type DeliveryRuleRequestURICondition struct {
	// REQUIRED; The name of the condition for the delivery rule.
	Name *MatchVariable

	// REQUIRED; Defines the parameters for the condition.
	Parameters *RequestURIMatchConditionParameters
}

DeliveryRuleRequestURICondition - Defines the RequestUri condition for the delivery rule.

func (*DeliveryRuleRequestURICondition) GetDeliveryRuleCondition 

func (d *DeliveryRuleRequestURICondition) GetDeliveryRuleCondition() *DeliveryRuleCondition

GetDeliveryRuleCondition implements the DeliveryRuleConditionClassification interface for type DeliveryRuleRequestURICondition.

func (DeliveryRuleRequestURICondition) MarshalJSON 

func (d DeliveryRuleRequestURICondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleRequestURICondition.

func (*DeliveryRuleRequestURICondition) UnmarshalJSON 

func (d *DeliveryRuleRequestURICondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleRequestURICondition.

type DeliveryRuleResponseHeaderAction 

type DeliveryRuleResponseHeaderAction struct {
	// REQUIRED; The name of the action for the delivery rule.
	Name *DeliveryRuleAction

	// REQUIRED; Defines the parameters for the action.
	Parameters *HeaderActionParameters
}

DeliveryRuleResponseHeaderAction - Defines the response header action for the delivery rule.

func (*DeliveryRuleResponseHeaderAction) GetDeliveryRuleActionAutoGenerated 

func (d *DeliveryRuleResponseHeaderAction) GetDeliveryRuleActionAutoGenerated() *DeliveryRuleActionAutoGenerated

GetDeliveryRuleActionAutoGenerated implements the DeliveryRuleActionAutoGeneratedClassification interface for type DeliveryRuleResponseHeaderAction.

func (DeliveryRuleResponseHeaderAction) MarshalJSON 

func (d DeliveryRuleResponseHeaderAction) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleResponseHeaderAction.

func (*DeliveryRuleResponseHeaderAction) UnmarshalJSON 

func (d *DeliveryRuleResponseHeaderAction) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleResponseHeaderAction.

type DeliveryRuleRouteConfigurationOverrideAction 

type DeliveryRuleRouteConfigurationOverrideAction struct {
	// REQUIRED; The name of the action for the delivery rule.
	Name *DeliveryRuleAction

	// REQUIRED; Defines the parameters for the action.
	Parameters *RouteConfigurationOverrideActionParameters
}

DeliveryRuleRouteConfigurationOverrideAction - Defines the route configuration override action for the delivery rule. Only applicable to Frontdoor Standard/Premium Profiles.

func (*DeliveryRuleRouteConfigurationOverrideAction) GetDeliveryRuleActionAutoGenerated 

func (d *DeliveryRuleRouteConfigurationOverrideAction) GetDeliveryRuleActionAutoGenerated() *DeliveryRuleActionAutoGenerated

GetDeliveryRuleActionAutoGenerated implements the DeliveryRuleActionAutoGeneratedClassification interface for type DeliveryRuleRouteConfigurationOverrideAction.

func (DeliveryRuleRouteConfigurationOverrideAction) MarshalJSON 

func (d DeliveryRuleRouteConfigurationOverrideAction) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleRouteConfigurationOverrideAction.

func (*DeliveryRuleRouteConfigurationOverrideAction) UnmarshalJSON 

func (d *DeliveryRuleRouteConfigurationOverrideAction) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleRouteConfigurationOverrideAction.

type DeliveryRuleSSLProtocolCondition 

type DeliveryRuleSSLProtocolCondition struct {
	// REQUIRED; The name of the condition for the delivery rule.
	Name *MatchVariable

	// REQUIRED; Defines the parameters for the condition.
	Parameters *SSLProtocolMatchConditionParameters
}

DeliveryRuleSSLProtocolCondition - Defines the SslProtocol condition for the delivery rule.

func (*DeliveryRuleSSLProtocolCondition) GetDeliveryRuleCondition 

func (d *DeliveryRuleSSLProtocolCondition) GetDeliveryRuleCondition() *DeliveryRuleCondition

GetDeliveryRuleCondition implements the DeliveryRuleConditionClassification interface for type DeliveryRuleSSLProtocolCondition.

func (DeliveryRuleSSLProtocolCondition) MarshalJSON 

func (d DeliveryRuleSSLProtocolCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleSSLProtocolCondition.

func (*DeliveryRuleSSLProtocolCondition) UnmarshalJSON 

func (d *DeliveryRuleSSLProtocolCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleSSLProtocolCondition.

type DeliveryRuleServerPortCondition 

type DeliveryRuleServerPortCondition struct {
	// REQUIRED; The name of the condition for the delivery rule.
	Name *MatchVariable

	// REQUIRED; Defines the parameters for the condition.
	Parameters *ServerPortMatchConditionParameters
}

DeliveryRuleServerPortCondition - Defines the ServerPort condition for the delivery rule.

func (*DeliveryRuleServerPortCondition) GetDeliveryRuleCondition 

func (d *DeliveryRuleServerPortCondition) GetDeliveryRuleCondition() *DeliveryRuleCondition

GetDeliveryRuleCondition implements the DeliveryRuleConditionClassification interface for type DeliveryRuleServerPortCondition.

func (DeliveryRuleServerPortCondition) MarshalJSON 

func (d DeliveryRuleServerPortCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleServerPortCondition.

func (*DeliveryRuleServerPortCondition) UnmarshalJSON 

func (d *DeliveryRuleServerPortCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleServerPortCondition.

type DeliveryRuleSocketAddrCondition 

type DeliveryRuleSocketAddrCondition struct {
	// REQUIRED; The name of the condition for the delivery rule.
	Name *MatchVariable

	// REQUIRED; Defines the parameters for the condition.
	Parameters *SocketAddrMatchConditionParameters
}

DeliveryRuleSocketAddrCondition - Defines the SocketAddress condition for the delivery rule.

func (*DeliveryRuleSocketAddrCondition) GetDeliveryRuleCondition 

func (d *DeliveryRuleSocketAddrCondition) GetDeliveryRuleCondition() *DeliveryRuleCondition

GetDeliveryRuleCondition implements the DeliveryRuleConditionClassification interface for type DeliveryRuleSocketAddrCondition.

func (DeliveryRuleSocketAddrCondition) MarshalJSON 

func (d DeliveryRuleSocketAddrCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleSocketAddrCondition.

func (*DeliveryRuleSocketAddrCondition) UnmarshalJSON 

func (d *DeliveryRuleSocketAddrCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleSocketAddrCondition.

type DeliveryRuleURLFileExtensionCondition 

type DeliveryRuleURLFileExtensionCondition struct {
	// REQUIRED; The name of the condition for the delivery rule.
	Name *MatchVariable

	// REQUIRED; Defines the parameters for the condition.
	Parameters *URLFileExtensionMatchConditionParameters
}

DeliveryRuleURLFileExtensionCondition - Defines the UrlFileExtension condition for the delivery rule.

func (*DeliveryRuleURLFileExtensionCondition) GetDeliveryRuleCondition 

func (d *DeliveryRuleURLFileExtensionCondition) GetDeliveryRuleCondition() *DeliveryRuleCondition

GetDeliveryRuleCondition implements the DeliveryRuleConditionClassification interface for type DeliveryRuleURLFileExtensionCondition.

func (DeliveryRuleURLFileExtensionCondition) MarshalJSON 

func (d DeliveryRuleURLFileExtensionCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleURLFileExtensionCondition.

func (*DeliveryRuleURLFileExtensionCondition) UnmarshalJSON 

func (d *DeliveryRuleURLFileExtensionCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleURLFileExtensionCondition.

type DeliveryRuleURLFileNameCondition 

type DeliveryRuleURLFileNameCondition struct {
	// REQUIRED; The name of the condition for the delivery rule.
	Name *MatchVariable

	// REQUIRED; Defines the parameters for the condition.
	Parameters *URLFileNameMatchConditionParameters
}

DeliveryRuleURLFileNameCondition - Defines the UrlFileName condition for the delivery rule.

func (*DeliveryRuleURLFileNameCondition) GetDeliveryRuleCondition 

func (d *DeliveryRuleURLFileNameCondition) GetDeliveryRuleCondition() *DeliveryRuleCondition

GetDeliveryRuleCondition implements the DeliveryRuleConditionClassification interface for type DeliveryRuleURLFileNameCondition.

func (DeliveryRuleURLFileNameCondition) MarshalJSON 

func (d DeliveryRuleURLFileNameCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleURLFileNameCondition.

func (*DeliveryRuleURLFileNameCondition) UnmarshalJSON 

func (d *DeliveryRuleURLFileNameCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleURLFileNameCondition.

type DeliveryRuleURLPathCondition 

type DeliveryRuleURLPathCondition struct {
	// REQUIRED; The name of the condition for the delivery rule.
	Name *MatchVariable

	// REQUIRED; Defines the parameters for the condition.
	Parameters *URLPathMatchConditionParameters
}

DeliveryRuleURLPathCondition - Defines the UrlPath condition for the delivery rule.

func (*DeliveryRuleURLPathCondition) GetDeliveryRuleCondition 

func (d *DeliveryRuleURLPathCondition) GetDeliveryRuleCondition() *DeliveryRuleCondition

GetDeliveryRuleCondition implements the DeliveryRuleConditionClassification interface for type DeliveryRuleURLPathCondition.

func (DeliveryRuleURLPathCondition) MarshalJSON 

func (d DeliveryRuleURLPathCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeliveryRuleURLPathCondition.

func (*DeliveryRuleURLPathCondition) UnmarshalJSON 

func (d *DeliveryRuleURLPathCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeliveryRuleURLPathCondition.

type DeploymentStatus 

type DeploymentStatus string
const (
	DeploymentStatusFailed     DeploymentStatus = "Failed"
	DeploymentStatusInProgress DeploymentStatus = "InProgress"
	DeploymentStatusNotStarted DeploymentStatus = "NotStarted"
	DeploymentStatusSucceeded  DeploymentStatus = "Succeeded"
)

func PossibleDeploymentStatusValues 

func PossibleDeploymentStatusValues() []DeploymentStatus

PossibleDeploymentStatusValues returns the possible values for the DeploymentStatus const type.

type DestinationProtocol 

type DestinationProtocol string

DestinationProtocol - Protocol to use for the redirect. The default value is MatchRequest 

const (
	DestinationProtocolHTTP         DestinationProtocol = "Http"
	DestinationProtocolHTTPS        DestinationProtocol = "Https"
	DestinationProtocolMatchRequest DestinationProtocol = "MatchRequest"
)

func PossibleDestinationProtocolValues 

func PossibleDestinationProtocolValues() []DestinationProtocol

PossibleDestinationProtocolValues returns the possible values for the DestinationProtocol const type.

type DimensionProperties 

type DimensionProperties struct {
	// Display name of dimension.
	DisplayName *string

	// Internal name of dimension.
	InternalName *string

	// Name of dimension.
	Name *string
}

DimensionProperties - Type of operation: get, read, delete, etc.

func (DimensionProperties) MarshalJSON 

func (d DimensionProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DimensionProperties.

func (*DimensionProperties) UnmarshalJSON 

func (d *DimensionProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DimensionProperties.

type DomainValidationProperties 

type DomainValidationProperties struct {
	// READ-ONLY; The date time that the token expires
	ExpirationDate *string

	// READ-ONLY; Challenge used for DNS TXT record or file based validation
	ValidationToken *string
}

DomainValidationProperties - The JSON object that contains the properties to validate a domain.

func (DomainValidationProperties) MarshalJSON 

func (d DomainValidationProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DomainValidationProperties.

func (*DomainValidationProperties) UnmarshalJSON 

func (d *DomainValidationProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DomainValidationProperties.

type DomainValidationState 

type DomainValidationState string

DomainValidationState - Provisioning substate shows the progress of custom HTTPS enabling/disabling process step by step. DCV stands for DomainControlValidation. 

const (
	DomainValidationStateApproved                  DomainValidationState = "Approved"
	DomainValidationStateInternalError             DomainValidationState = "InternalError"
	DomainValidationStatePending                   DomainValidationState = "Pending"
	DomainValidationStatePendingRevalidation       DomainValidationState = "PendingRevalidation"
	DomainValidationStateRefreshingValidationToken DomainValidationState = "RefreshingValidationToken"
	DomainValidationStateRejected                  DomainValidationState = "Rejected"
	DomainValidationStateSubmitting                DomainValidationState = "Submitting"
	DomainValidationStateTimedOut                  DomainValidationState = "TimedOut"
	DomainValidationStateUnknown                   DomainValidationState = "Unknown"
)

func PossibleDomainValidationStateValues 

func PossibleDomainValidationStateValues() []DomainValidationState

PossibleDomainValidationStateValues returns the possible values for the DomainValidationState const type.

type EdgeNode 

type EdgeNode struct {
	// The JSON object that contains the properties required to create an edgenode.
	Properties *EdgeNodeProperties

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Read only system data
	SystemData *SystemData

	// READ-ONLY; Resource type.
	Type *string
}

EdgeNode - Edgenode is a global Point of Presence (POP) location used to deliver CDN content to end users.

func (EdgeNode) MarshalJSON 

func (e EdgeNode) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type EdgeNode.

func (*EdgeNode) UnmarshalJSON 

func (e *EdgeNode) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type EdgeNode.

type EdgeNodeProperties 

type EdgeNodeProperties struct {
	// REQUIRED; List of ip address groups.
	IPAddressGroups []*IPAddressGroup
}

EdgeNodeProperties - The JSON object that contains the properties required to create an edgenode.

func (EdgeNodeProperties) MarshalJSON 

func (e EdgeNodeProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type EdgeNodeProperties.

func (*EdgeNodeProperties) UnmarshalJSON 

func (e *EdgeNodeProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type EdgeNodeProperties.

type EdgeNodesClient 

type EdgeNodesClient struct {
	// contains filtered or unexported fields
}

EdgeNodesClient contains the methods for the EdgeNodes group. Don't use this type directly, use NewEdgeNodesClient() instead.

func NewEdgeNodesClient 

func NewEdgeNodesClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*EdgeNodesClient, error)

NewEdgeNodesClient creates a new instance of EdgeNodesClient with the specified values.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*EdgeNodesClient) NewListPager 

func (client *EdgeNodesClient) NewListPager(options *EdgeNodesClientListOptions) *runtime.Pager[EdgeNodesClientListResponse]

NewListPager - Edgenodes are the global Point of Presence (POP) locations used to deliver CDN content to end users.

Generated from API version 2024-02-01

  • options - EdgeNodesClientListOptions contains the optional parameters for the EdgeNodesClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/EdgeNodes_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewEdgeNodesClient().NewListPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.EdgenodeResult = armcdn.EdgenodeResult{
	// 	Value: []*armcdn.EdgeNode{
	// 		{
	// 			Name: to.Ptr("Standard_Verizon"),
	// 			Type: to.Ptr("Microsoft.Cdn/edgenodes"),
	// 			ID: to.Ptr("/providers/Microsoft.Cdn/edgenodes/Standard_Verizon"),
	// 			Properties: &armcdn.EdgeNodeProperties{
	// 				IPAddressGroups: []*armcdn.IPAddressGroup{
	// 					{
	// 						DeliveryRegion: to.Ptr("All"),
	// 						IPv4Addresses: []*armcdn.CidrIPAddress{
	// 							{
	// 								BaseIPAddress: to.Ptr("192.229.176.0"),
	// 								PrefixLength: to.Ptr[int32](24),
	// 							},
	// 							{
	// 								BaseIPAddress: to.Ptr("180.240.184.128"),
	// 								PrefixLength: to.Ptr[int32](25),
	// 							},
	// 							{
	// 								BaseIPAddress: to.Ptr("152.195.27.0"),
	// 								PrefixLength: to.Ptr[int32](24),
	// 						}},
	// 						IPv6Addresses: []*armcdn.CidrIPAddress{
	// 							{
	// 								BaseIPAddress: to.Ptr("2606:2800:60f2::"),
	// 								PrefixLength: to.Ptr[int32](48),
	// 							},
	// 							{
	// 								BaseIPAddress: to.Ptr("2606:2800:700c::"),
	// 								PrefixLength: to.Ptr[int32](48),
	// 						}},
	// 				}},
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Premium_Verizon"),
	// 			Type: to.Ptr("Microsoft.Cdn/edgenodes"),
	// 			ID: to.Ptr("/providers/Microsoft.Cdn/edgenodes/Premium_Verizon"),
	// 			Properties: &armcdn.EdgeNodeProperties{
	// 				IPAddressGroups: []*armcdn.IPAddressGroup{
	// 					{
	// 						DeliveryRegion: to.Ptr("All"),
	// 						IPv4Addresses: []*armcdn.CidrIPAddress{
	// 							{
	// 								BaseIPAddress: to.Ptr("192.229.176.0"),
	// 								PrefixLength: to.Ptr[int32](24),
	// 							},
	// 							{
	// 								BaseIPAddress: to.Ptr("152.195.27.0"),
	// 								PrefixLength: to.Ptr[int32](24),
	// 						}},
	// 						IPv6Addresses: []*armcdn.CidrIPAddress{
	// 							{
	// 								BaseIPAddress: to.Ptr("2606:2800:60f2::"),
	// 								PrefixLength: to.Ptr[int32](48),
	// 							},
	// 							{
	// 								BaseIPAddress: to.Ptr("2606:2800:700c::"),
	// 								PrefixLength: to.Ptr[int32](48),
	// 						}},
	// 				}},
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Custom_Verizon"),
	// 			Type: to.Ptr("Microsoft.Cdn/edgenodes"),
	// 			ID: to.Ptr("/providers/Microsoft.Cdn/edgenodes/Custom_Verizon"),
	// 			Properties: &armcdn.EdgeNodeProperties{
	// 				IPAddressGroups: []*armcdn.IPAddressGroup{
	// 					{
	// 						DeliveryRegion: to.Ptr("All"),
	// 						IPv4Addresses: []*armcdn.CidrIPAddress{
	// 							{
	// 								BaseIPAddress: to.Ptr("192.229.176.0"),
	// 								PrefixLength: to.Ptr[int32](24),
	// 							},
	// 							{
	// 								BaseIPAddress: to.Ptr("2606:2800:420b::"),
	// 								PrefixLength: to.Ptr[int32](48),
	// 							},
	// 							{
	// 								BaseIPAddress: to.Ptr("2606:2800:700c::"),
	// 								PrefixLength: to.Ptr[int32](48),
	// 						}},
	// 				}},
	// 			},
	// 	}},
	// }
}

Output:

type EdgeNodesClientListOptions 

type EdgeNodesClientListOptions struct {
}

EdgeNodesClientListOptions contains the optional parameters for the EdgeNodesClient.NewListPager method.

type EdgeNodesClientListResponse 

type EdgeNodesClientListResponse struct {
	// Result of the request to list CDN edgenodes. It contains a list of ip address group and a URL link to get the next set
	// of results.
	EdgenodeResult
}

EdgeNodesClientListResponse contains the response from method EdgeNodesClient.NewListPager.

type EdgenodeResult 

type EdgenodeResult struct {
	// URL to get the next set of edgenode list results if there are any.
	NextLink *string

	// READ-ONLY; Edge node of CDN service.
	Value []*EdgeNode
}

EdgenodeResult - Result of the request to list CDN edgenodes. It contains a list of ip address group and a URL link to get the next set of results.

func (EdgenodeResult) MarshalJSON 

func (e EdgenodeResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type EdgenodeResult.

func (*EdgenodeResult) UnmarshalJSON 

func (e *EdgenodeResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type EdgenodeResult.

type EnabledState 

type EnabledState string

EnabledState - Whether to enable use of this rule. Permitted values are 'Enabled' or 'Disabled' 

const (
	EnabledStateDisabled EnabledState = "Disabled"
	EnabledStateEnabled  EnabledState = "Enabled"
)

func PossibleEnabledStateValues 

func PossibleEnabledStateValues() []EnabledState

PossibleEnabledStateValues returns the possible values for the EnabledState const type.

type Endpoint 

type Endpoint struct {
	// REQUIRED; Resource location.
	Location *string

	// The JSON object that contains the properties required to create an endpoint.
	Properties *EndpointProperties

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Read only system data
	SystemData *SystemData

	// READ-ONLY; Resource type.
	Type *string
}

Endpoint - CDN endpoint is the entity within a CDN profile containing configuration information such as origin, protocol, content caching and delivery behavior. The CDN endpoint uses the URL format .azureedge.net.

func (Endpoint) MarshalJSON 

func (e Endpoint) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Endpoint.

func (*Endpoint) UnmarshalJSON 

func (e *Endpoint) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Endpoint.

type EndpointListResult 

type EndpointListResult struct {
	// URL to get the next set of endpoint objects if there is any.
	NextLink *string

	// READ-ONLY; List of CDN endpoints within a profile
	Value []*Endpoint
}

EndpointListResult - Result of the request to list endpoints. It contains a list of endpoint objects and a URL link to get the next set of results.

func (EndpointListResult) MarshalJSON 

func (e EndpointListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type EndpointListResult.

func (*EndpointListResult) UnmarshalJSON 

func (e *EndpointListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type EndpointListResult.

type EndpointProperties 

type EndpointProperties struct {
	// REQUIRED; The source of the content being delivered via CDN.
	Origins []*DeepCreatedOrigin

	// List of content types on which compression applies. The value should be a valid MIME type.
	ContentTypesToCompress []*string

	// A reference to the origin group.
	DefaultOriginGroup *ResourceReference

	// A policy that specifies the delivery rules to be used for an endpoint.
	DeliveryPolicy *EndpointPropertiesUpdateParametersDeliveryPolicy

	// List of rules defining the user's geo access within a CDN endpoint. Each geo filter defines an access rule to a specified
	// path or content, e.g. block APAC for path /pictures/
	GeoFilters []*GeoFilter

	// Indicates whether content compression is enabled on CDN. Default value is false. If compression is enabled, content will
	// be served as compressed if user requests for a compressed version. Content
	// won't be compressed on CDN when requested content is smaller than 1 byte or larger than 1 MB.
	IsCompressionEnabled *bool

	// Indicates whether HTTP traffic is allowed on the endpoint. Default value is true. At least one protocol (HTTP or HTTPS)
	// must be allowed.
	IsHTTPAllowed *bool

	// Indicates whether HTTPS traffic is allowed on the endpoint. Default value is true. At least one protocol (HTTP or HTTPS)
	// must be allowed.
	IsHTTPSAllowed *bool

	// Specifies what scenario the customer wants this CDN endpoint to optimize for, e.g. Download, Media services. With this
	// information, CDN can apply scenario driven optimization.
	OptimizationType *OptimizationType

	// The origin groups comprising of origins that are used for load balancing the traffic based on availability.
	OriginGroups []*DeepCreatedOriginGroup

	// The host header value sent to the origin with each request. This property at Endpoint is only allowed when endpoint uses
	// single origin and can be overridden by the same property specified at origin.If
	// you leave this blank, the request hostname determines this value. Azure CDN origins, such as Web Apps, Blob Storage, and
	// Cloud Services require this host header value to match the origin hostname by
	// default.
	OriginHostHeader *string

	// A directory path on the origin that CDN can use to retrieve content from, e.g. contoso.cloudapp.net/originpath.
	OriginPath *string

	// Path to a file hosted on the origin which helps accelerate delivery of the dynamic content and calculate the most optimal
	// routes for the CDN. This is relative to the origin path. This property is only
	// relevant when using a single origin.
	ProbePath *string

	// Defines how CDN caches requests that include query strings. You can ignore any query strings when caching, bypass caching
	// to prevent requests that contain query strings from being cached, or cache
	// every request with a unique URL.
	QueryStringCachingBehavior *QueryStringCachingBehavior

	// List of keys used to validate the signed URL hashes.
	URLSigningKeys []*URLSigningKey

	// Defines the Web Application Firewall policy for the endpoint (if applicable)
	WebApplicationFirewallPolicyLink *EndpointPropertiesUpdateParametersWebApplicationFirewallPolicyLink

	// READ-ONLY; The custom domains under the endpoint.
	CustomDomains []*DeepCreatedCustomDomain

	// READ-ONLY; The host name of the endpoint structured as {endpointName}.{DNSZone}, e.g. contoso.azureedge.net
	HostName *string

	// READ-ONLY; Provisioning status of the endpoint.
	ProvisioningState *EndpointProvisioningState

	// READ-ONLY; Resource status of the endpoint.
	ResourceState *EndpointResourceState
}

EndpointProperties - The JSON object that contains the properties required to create an endpoint.

func (EndpointProperties) MarshalJSON 

func (e EndpointProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type EndpointProperties.

func (*EndpointProperties) UnmarshalJSON 

func (e *EndpointProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type EndpointProperties.

type EndpointPropertiesUpdateParameters 

type EndpointPropertiesUpdateParameters struct {
	// List of content types on which compression applies. The value should be a valid MIME type.
	ContentTypesToCompress []*string

	// A reference to the origin group.
	DefaultOriginGroup *ResourceReference

	// A policy that specifies the delivery rules to be used for an endpoint.
	DeliveryPolicy *EndpointPropertiesUpdateParametersDeliveryPolicy

	// List of rules defining the user's geo access within a CDN endpoint. Each geo filter defines an access rule to a specified
	// path or content, e.g. block APAC for path /pictures/
	GeoFilters []*GeoFilter

	// Indicates whether content compression is enabled on CDN. Default value is false. If compression is enabled, content will
	// be served as compressed if user requests for a compressed version. Content
	// won't be compressed on CDN when requested content is smaller than 1 byte or larger than 1 MB.
	IsCompressionEnabled *bool

	// Indicates whether HTTP traffic is allowed on the endpoint. Default value is true. At least one protocol (HTTP or HTTPS)
	// must be allowed.
	IsHTTPAllowed *bool

	// Indicates whether HTTPS traffic is allowed on the endpoint. Default value is true. At least one protocol (HTTP or HTTPS)
	// must be allowed.
	IsHTTPSAllowed *bool

	// Specifies what scenario the customer wants this CDN endpoint to optimize for, e.g. Download, Media services. With this
	// information, CDN can apply scenario driven optimization.
	OptimizationType *OptimizationType

	// The host header value sent to the origin with each request. This property at Endpoint is only allowed when endpoint uses
	// single origin and can be overridden by the same property specified at origin.If
	// you leave this blank, the request hostname determines this value. Azure CDN origins, such as Web Apps, Blob Storage, and
	// Cloud Services require this host header value to match the origin hostname by
	// default.
	OriginHostHeader *string

	// A directory path on the origin that CDN can use to retrieve content from, e.g. contoso.cloudapp.net/originpath.
	OriginPath *string

	// Path to a file hosted on the origin which helps accelerate delivery of the dynamic content and calculate the most optimal
	// routes for the CDN. This is relative to the origin path. This property is only
	// relevant when using a single origin.
	ProbePath *string

	// Defines how CDN caches requests that include query strings. You can ignore any query strings when caching, bypass caching
	// to prevent requests that contain query strings from being cached, or cache
	// every request with a unique URL.
	QueryStringCachingBehavior *QueryStringCachingBehavior

	// List of keys used to validate the signed URL hashes.
	URLSigningKeys []*URLSigningKey

	// Defines the Web Application Firewall policy for the endpoint (if applicable)
	WebApplicationFirewallPolicyLink *EndpointPropertiesUpdateParametersWebApplicationFirewallPolicyLink
}

EndpointPropertiesUpdateParameters - The JSON object containing endpoint update parameters.

func (EndpointPropertiesUpdateParameters) MarshalJSON 

func (e EndpointPropertiesUpdateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type EndpointPropertiesUpdateParameters.

func (*EndpointPropertiesUpdateParameters) UnmarshalJSON 

func (e *EndpointPropertiesUpdateParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type EndpointPropertiesUpdateParameters.

type EndpointPropertiesUpdateParametersDeliveryPolicy 

type EndpointPropertiesUpdateParametersDeliveryPolicy struct {
	// REQUIRED; A list of the delivery rules.
	Rules []*DeliveryRule

	// User-friendly description of the policy.
	Description *string
}

EndpointPropertiesUpdateParametersDeliveryPolicy - A policy that specifies the delivery rules to be used for an endpoint.

func (EndpointPropertiesUpdateParametersDeliveryPolicy) MarshalJSON 

func (e EndpointPropertiesUpdateParametersDeliveryPolicy) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type EndpointPropertiesUpdateParametersDeliveryPolicy.

func (*EndpointPropertiesUpdateParametersDeliveryPolicy) UnmarshalJSON 

func (e *EndpointPropertiesUpdateParametersDeliveryPolicy) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type EndpointPropertiesUpdateParametersDeliveryPolicy. 

type EndpointPropertiesUpdateParametersWebApplicationFirewallPolicyLink struct {
	// Resource ID.
	ID *string
}

EndpointPropertiesUpdateParametersWebApplicationFirewallPolicyLink - Defines the Web Application Firewall policy for the endpoint (if applicable)

func (EndpointPropertiesUpdateParametersWebApplicationFirewallPolicyLink) MarshalJSON 

func (e EndpointPropertiesUpdateParametersWebApplicationFirewallPolicyLink) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type EndpointPropertiesUpdateParametersWebApplicationFirewallPolicyLink.

func (*EndpointPropertiesUpdateParametersWebApplicationFirewallPolicyLink) UnmarshalJSON 

func (e *EndpointPropertiesUpdateParametersWebApplicationFirewallPolicyLink) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type EndpointPropertiesUpdateParametersWebApplicationFirewallPolicyLink.

type EndpointProvisioningState 

type EndpointProvisioningState string

EndpointProvisioningState - Provisioning status of the endpoint. 

const (
	EndpointProvisioningStateCreating  EndpointProvisioningState = "Creating"
	EndpointProvisioningStateDeleting  EndpointProvisioningState = "Deleting"
	EndpointProvisioningStateFailed    EndpointProvisioningState = "Failed"
	EndpointProvisioningStateSucceeded EndpointProvisioningState = "Succeeded"
	EndpointProvisioningStateUpdating  EndpointProvisioningState = "Updating"
)

func PossibleEndpointProvisioningStateValues 

func PossibleEndpointProvisioningStateValues() []EndpointProvisioningState

PossibleEndpointProvisioningStateValues returns the possible values for the EndpointProvisioningState const type.

type EndpointResourceState 

type EndpointResourceState string

EndpointResourceState - Resource status of the endpoint. 

const (
	EndpointResourceStateCreating EndpointResourceState = "Creating"
	EndpointResourceStateDeleting EndpointResourceState = "Deleting"
	EndpointResourceStateRunning  EndpointResourceState = "Running"
	EndpointResourceStateStarting EndpointResourceState = "Starting"
	EndpointResourceStateStopped  EndpointResourceState = "Stopped"
	EndpointResourceStateStopping EndpointResourceState = "Stopping"
)

func PossibleEndpointResourceStateValues 

func PossibleEndpointResourceStateValues() []EndpointResourceState

PossibleEndpointResourceStateValues returns the possible values for the EndpointResourceState const type.

type EndpointUpdateParameters 

type EndpointUpdateParameters struct {
	// The JSON object containing endpoint update parameters.
	Properties *EndpointPropertiesUpdateParameters

	// Endpoint tags.
	Tags map[string]*string
}

EndpointUpdateParameters - Properties required to create or update an endpoint.

func (EndpointUpdateParameters) MarshalJSON 

func (e EndpointUpdateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type EndpointUpdateParameters.

func (*EndpointUpdateParameters) UnmarshalJSON 

func (e *EndpointUpdateParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type EndpointUpdateParameters.

type EndpointsClient 

type EndpointsClient struct {
	// contains filtered or unexported fields
}

EndpointsClient contains the methods for the Endpoints group. Don't use this type directly, use NewEndpointsClient() instead.

func NewEndpointsClient 

func NewEndpointsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*EndpointsClient, error)

NewEndpointsClient creates a new instance of EndpointsClient with the specified values.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*EndpointsClient) BeginCreate 

func (client *EndpointsClient) BeginCreate(ctx context.Context, resourceGroupName string, profileName string, endpointName string, endpoint Endpoint, options *EndpointsClientBeginCreateOptions) (*runtime.Poller[EndpointsClientCreateResponse], error)

BeginCreate - Creates a new CDN endpoint with the specified endpoint name under the specified subscription, resource group and profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • endpoint - Endpoint properties
  • options - EndpointsClientBeginCreateOptions contains the optional parameters for the EndpointsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Endpoints_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewEndpointsClient().BeginCreate(ctx, "RG", "profile1", "endpoint1", armcdn.Endpoint{
	Location: to.Ptr("WestUs"),
	Tags: map[string]*string{
		"key1": to.Ptr("value1"),
	},
	Properties: &armcdn.EndpointProperties{
		ContentTypesToCompress: []*string{
			to.Ptr("text/html"),
			to.Ptr("application/octet-stream")},
		DefaultOriginGroup: &armcdn.ResourceReference{
			ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/originGroups/originGroup1"),
		},
		DeliveryPolicy: &armcdn.EndpointPropertiesUpdateParametersDeliveryPolicy{
			Description: to.Ptr("Test description for a policy."),
			Rules: []*armcdn.DeliveryRule{
				{
					Name: to.Ptr("rule1"),
					Actions: []armcdn.DeliveryRuleActionAutoGeneratedClassification{
						&armcdn.DeliveryRuleCacheExpirationAction{
							Name: to.Ptr(armcdn.DeliveryRuleActionCacheExpiration),
							Parameters: &armcdn.CacheExpirationActionParameters{
								CacheBehavior: to.Ptr(armcdn.CacheBehaviorOverride),
								CacheDuration: to.Ptr("10:10:09"),
								CacheType:     to.Ptr(armcdn.CacheTypeAll),
								TypeName:      to.Ptr(armcdn.CacheExpirationActionParametersTypeNameDeliveryRuleCacheExpirationActionParameters),
							},
						},
						&armcdn.DeliveryRuleResponseHeaderAction{
							Name: to.Ptr(armcdn.DeliveryRuleActionModifyResponseHeader),
							Parameters: &armcdn.HeaderActionParameters{
								HeaderAction: to.Ptr(armcdn.HeaderActionOverwrite),
								HeaderName:   to.Ptr("Access-Control-Allow-Origin"),
								TypeName:     to.Ptr(armcdn.HeaderActionParametersTypeNameDeliveryRuleHeaderActionParameters),
								Value:        to.Ptr("*"),
							},
						},
						&armcdn.DeliveryRuleRequestHeaderAction{
							Name: to.Ptr(armcdn.DeliveryRuleActionModifyRequestHeader),
							Parameters: &armcdn.HeaderActionParameters{
								HeaderAction: to.Ptr(armcdn.HeaderActionOverwrite),
								HeaderName:   to.Ptr("Accept-Encoding"),
								TypeName:     to.Ptr(armcdn.HeaderActionParametersTypeNameDeliveryRuleHeaderActionParameters),
								Value:        to.Ptr("gzip"),
							},
						}},
					Conditions: []armcdn.DeliveryRuleConditionClassification{
						&armcdn.DeliveryRuleRemoteAddressCondition{
							Name: to.Ptr(armcdn.MatchVariableRemoteAddress),
							Parameters: &armcdn.RemoteAddressMatchConditionParameters{
								MatchValues: []*string{
									to.Ptr("192.168.1.0/24"),
									to.Ptr("10.0.0.0/24")},
								NegateCondition: to.Ptr(true),
								Operator:        to.Ptr(armcdn.RemoteAddressOperatorIPMatch),
								TypeName:        to.Ptr(armcdn.RemoteAddressMatchConditionParametersTypeNameDeliveryRuleRemoteAddressConditionParameters),
							},
						}},
					Order: to.Ptr[int32](1),
				}},
		},
		IsCompressionEnabled:       to.Ptr(true),
		IsHTTPAllowed:              to.Ptr(true),
		IsHTTPSAllowed:             to.Ptr(true),
		OriginHostHeader:           to.Ptr("www.bing.com"),
		OriginPath:                 to.Ptr("/photos"),
		QueryStringCachingBehavior: to.Ptr(armcdn.QueryStringCachingBehaviorBypassCaching),
		OriginGroups: []*armcdn.DeepCreatedOriginGroup{
			{
				Name: to.Ptr("originGroup1"),
				Properties: &armcdn.DeepCreatedOriginGroupProperties{
					HealthProbeSettings: &armcdn.HealthProbeParameters{
						ProbeIntervalInSeconds: to.Ptr[int32](120),
						ProbePath:              to.Ptr("/health.aspx"),
						ProbeProtocol:          to.Ptr(armcdn.ProbeProtocolHTTP),
						ProbeRequestType:       to.Ptr(armcdn.HealthProbeRequestTypeGET),
					},
					Origins: []*armcdn.ResourceReference{
						{
							ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/origins/origin1"),
						},
						{
							ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/origins/origin2"),
						}},
					ResponseBasedOriginErrorDetectionSettings: &armcdn.ResponseBasedOriginErrorDetectionParameters{
						ResponseBasedDetectedErrorTypes:          to.Ptr(armcdn.ResponseBasedDetectedErrorTypesTCPErrorsOnly),
						ResponseBasedFailoverThresholdPercentage: to.Ptr[int32](10),
					},
				},
			}},
		Origins: []*armcdn.DeepCreatedOrigin{
			{
				Name: to.Ptr("origin1"),
				Properties: &armcdn.DeepCreatedOriginProperties{
					Enabled:          to.Ptr(true),
					HostName:         to.Ptr("www.someDomain1.net"),
					HTTPPort:         to.Ptr[int32](80),
					HTTPSPort:        to.Ptr[int32](443),
					OriginHostHeader: to.Ptr("www.someDomain1.net"),
					Priority:         to.Ptr[int32](1),
					Weight:           to.Ptr[int32](50),
				},
			},
			{
				Name: to.Ptr("origin2"),
				Properties: &armcdn.DeepCreatedOriginProperties{
					Enabled:          to.Ptr(true),
					HostName:         to.Ptr("www.someDomain2.net"),
					HTTPPort:         to.Ptr[int32](80),
					HTTPSPort:        to.Ptr[int32](443),
					OriginHostHeader: to.Ptr("www.someDomain2.net"),
					Priority:         to.Ptr[int32](2),
					Weight:           to.Ptr[int32](50),
				},
			}},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Endpoint = armcdn.Endpoint{
// 	Name: to.Ptr("endpoint4899"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/endpoints"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1"),
// 	Location: to.Ptr("WestUs"),
// 	Tags: map[string]*string{
// 		"kay1": to.Ptr("value1"),
// 	},
// 	Properties: &armcdn.EndpointProperties{
// 		ContentTypesToCompress: []*string{
// 			to.Ptr("text/html"),
// 			to.Ptr("application/octet-stream")},
// 			DefaultOriginGroup: &armcdn.ResourceReference{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/originGroups/originGroup1"),
// 			},
// 			DeliveryPolicy: &armcdn.EndpointPropertiesUpdateParametersDeliveryPolicy{
// 				Description: to.Ptr("Test description for a policy."),
// 				Rules: []*armcdn.DeliveryRule{
// 					{
// 						Name: to.Ptr("rule1"),
// 						Actions: []armcdn.DeliveryRuleActionAutoGeneratedClassification{
// 							&armcdn.DeliveryRuleCacheExpirationAction{
// 								Name: to.Ptr(armcdn.DeliveryRuleActionCacheExpiration),
// 								Parameters: &armcdn.CacheExpirationActionParameters{
// 									CacheBehavior: to.Ptr(armcdn.CacheBehaviorOverride),
// 									CacheDuration: to.Ptr("10:10:09"),
// 									CacheType: to.Ptr(armcdn.CacheTypeAll),
// 									TypeName: to.Ptr(armcdn.CacheExpirationActionParametersTypeNameDeliveryRuleCacheExpirationActionParameters),
// 								},
// 							},
// 							&armcdn.DeliveryRuleResponseHeaderAction{
// 								Name: to.Ptr(armcdn.DeliveryRuleActionModifyResponseHeader),
// 								Parameters: &armcdn.HeaderActionParameters{
// 									HeaderAction: to.Ptr(armcdn.HeaderActionOverwrite),
// 									HeaderName: to.Ptr("Access-Control-Allow-Origin"),
// 									TypeName: to.Ptr(armcdn.HeaderActionParametersTypeNameDeliveryRuleHeaderActionParameters),
// 									Value: to.Ptr("*"),
// 								},
// 							},
// 							&armcdn.DeliveryRuleRequestHeaderAction{
// 								Name: to.Ptr(armcdn.DeliveryRuleActionModifyRequestHeader),
// 								Parameters: &armcdn.HeaderActionParameters{
// 									HeaderAction: to.Ptr(armcdn.HeaderActionOverwrite),
// 									HeaderName: to.Ptr("Accept-Encoding"),
// 									TypeName: to.Ptr(armcdn.HeaderActionParametersTypeNameDeliveryRuleHeaderActionParameters),
// 									Value: to.Ptr("gzip"),
// 								},
// 						}},
// 						Conditions: []armcdn.DeliveryRuleConditionClassification{
// 							&armcdn.DeliveryRuleRemoteAddressCondition{
// 								Name: to.Ptr(armcdn.MatchVariableRemoteAddress),
// 								Parameters: &armcdn.RemoteAddressMatchConditionParameters{
// 									MatchValues: []*string{
// 										to.Ptr("192.168.1.0/24"),
// 										to.Ptr("10.0.0.0/24")},
// 										NegateCondition: to.Ptr(true),
// 										Operator: to.Ptr(armcdn.RemoteAddressOperatorIPMatch),
// 										Transforms: []*armcdn.Transform{
// 										},
// 										TypeName: to.Ptr(armcdn.RemoteAddressMatchConditionParametersTypeNameDeliveryRuleRemoteAddressConditionParameters),
// 									},
// 							}},
// 							Order: to.Ptr[int32](1),
// 					}},
// 				},
// 				GeoFilters: []*armcdn.GeoFilter{
// 				},
// 				IsCompressionEnabled: to.Ptr(true),
// 				IsHTTPAllowed: to.Ptr(true),
// 				IsHTTPSAllowed: to.Ptr(true),
// 				OriginHostHeader: to.Ptr("www.bing.com"),
// 				OriginPath: to.Ptr("/photos"),
// 				QueryStringCachingBehavior: to.Ptr(armcdn.QueryStringCachingBehaviorBypassCaching),
// 				HostName: to.Ptr("endpoint4899.azureedge-test.net"),
// 				OriginGroups: []*armcdn.DeepCreatedOriginGroup{
// 					{
// 						Name: to.Ptr("originGroup1"),
// 						Properties: &armcdn.DeepCreatedOriginGroupProperties{
// 							HealthProbeSettings: &armcdn.HealthProbeParameters{
// 								ProbeIntervalInSeconds: to.Ptr[int32](120),
// 								ProbePath: to.Ptr("/health.aspx"),
// 								ProbeProtocol: to.Ptr(armcdn.ProbeProtocolHTTP),
// 								ProbeRequestType: to.Ptr(armcdn.HealthProbeRequestTypeGET),
// 							},
// 							Origins: []*armcdn.ResourceReference{
// 								{
// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/origins/origin1"),
// 								},
// 								{
// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/origins/origin2"),
// 							}},
// 							ResponseBasedOriginErrorDetectionSettings: &armcdn.ResponseBasedOriginErrorDetectionParameters{
// 								ResponseBasedDetectedErrorTypes: to.Ptr(armcdn.ResponseBasedDetectedErrorTypesTCPErrorsOnly),
// 								ResponseBasedFailoverThresholdPercentage: to.Ptr[int32](10),
// 							},
// 						},
// 				}},
// 				Origins: []*armcdn.DeepCreatedOrigin{
// 					{
// 						Name: to.Ptr("origin1"),
// 						Properties: &armcdn.DeepCreatedOriginProperties{
// 							Enabled: to.Ptr(true),
// 							HostName: to.Ptr("www.someDomain1.net"),
// 							HTTPPort: to.Ptr[int32](80),
// 							HTTPSPort: to.Ptr[int32](443),
// 							OriginHostHeader: to.Ptr("www.someDomain1.net"),
// 							Priority: to.Ptr[int32](1),
// 							Weight: to.Ptr[int32](50),
// 						},
// 					},
// 					{
// 						Name: to.Ptr("origin2"),
// 						Properties: &armcdn.DeepCreatedOriginProperties{
// 							Enabled: to.Ptr(true),
// 							HostName: to.Ptr("www.someDomain2.net"),
// 							HTTPPort: to.Ptr[int32](80),
// 							HTTPSPort: to.Ptr[int32](443),
// 							OriginHostHeader: to.Ptr("www.someDomain2.net"),
// 							Priority: to.Ptr[int32](2),
// 							Weight: to.Ptr[int32](50),
// 						},
// 				}},
// 				ProvisioningState: to.Ptr(armcdn.EndpointProvisioningStateSucceeded),
// 				ResourceState: to.Ptr(armcdn.EndpointResourceStateCreating),
// 			},
// 		}

Output:

func (*EndpointsClient) BeginDelete 

func (client *EndpointsClient) BeginDelete(ctx context.Context, resourceGroupName string, profileName string, endpointName string, options *EndpointsClientBeginDeleteOptions) (*runtime.Poller[EndpointsClientDeleteResponse], error)

BeginDelete - Deletes an existing CDN endpoint with the specified endpoint name under the specified subscription, resource group and profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • options - EndpointsClientBeginDeleteOptions contains the optional parameters for the EndpointsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Endpoints_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewEndpointsClient().BeginDelete(ctx, "RG", "profile1", "endpoint1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*EndpointsClient) BeginLoadContent 

func (client *EndpointsClient) BeginLoadContent(ctx context.Context, resourceGroupName string, profileName string, endpointName string, contentFilePaths LoadParameters, options *EndpointsClientBeginLoadContentOptions) (*runtime.Poller[EndpointsClientLoadContentResponse], error)

BeginLoadContent - Pre-loads a content to CDN. Available for Verizon Profiles. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • contentFilePaths - The path to the content to be loaded. Path should be a full URL, e.g. ‘/pictures/city.png' which loads a single file
  • options - EndpointsClientBeginLoadContentOptions contains the optional parameters for the EndpointsClient.BeginLoadContent method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Endpoints_LoadContent.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewEndpointsClient().BeginLoadContent(ctx, "RG", "profile1", "endpoint1", armcdn.LoadParameters{
	ContentPaths: []*string{
		to.Ptr("/folder1")},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*EndpointsClient) BeginPurgeContent 

func (client *EndpointsClient) BeginPurgeContent(ctx context.Context, resourceGroupName string, profileName string, endpointName string, contentFilePaths PurgeParameters, options *EndpointsClientBeginPurgeContentOptions) (*runtime.Poller[EndpointsClientPurgeContentResponse], error)

BeginPurgeContent - Removes a content from CDN. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • contentFilePaths - The path to the content to be purged. Path can be a full URL, e.g. '/pictures/city.png' which removes a single file, or a directory with a wildcard, e.g. '/pictures/*' which removes all folders and files in the directory.
  • options - EndpointsClientBeginPurgeContentOptions contains the optional parameters for the EndpointsClient.BeginPurgeContent method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Endpoints_PurgeContent.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewEndpointsClient().BeginPurgeContent(ctx, "RG", "profile1", "endpoint1", armcdn.PurgeParameters{
	ContentPaths: []*string{
		to.Ptr("/folder1")},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*EndpointsClient) BeginStart 

func (client *EndpointsClient) BeginStart(ctx context.Context, resourceGroupName string, profileName string, endpointName string, options *EndpointsClientBeginStartOptions) (*runtime.Poller[EndpointsClientStartResponse], error)

BeginStart - Starts an existing CDN endpoint that is on a stopped state. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • options - EndpointsClientBeginStartOptions contains the optional parameters for the EndpointsClient.BeginStart method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Endpoints_Start.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewEndpointsClient().BeginStart(ctx, "RG", "profile1", "endpoint1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Endpoint = armcdn.Endpoint{
// 	Name: to.Ptr("endpoint4899"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/endpoints"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1"),
// 	Location: to.Ptr("WestUs"),
// 	Tags: map[string]*string{
// 		"kay1": to.Ptr("value1"),
// 	},
// 	Properties: &armcdn.EndpointProperties{
// 		ContentTypesToCompress: []*string{
// 		},
// 		GeoFilters: []*armcdn.GeoFilter{
// 		},
// 		IsCompressionEnabled: to.Ptr(false),
// 		IsHTTPAllowed: to.Ptr(true),
// 		IsHTTPSAllowed: to.Ptr(true),
// 		OptimizationType: to.Ptr(armcdn.OptimizationTypeDynamicSiteAcceleration),
// 		OriginHostHeader: to.Ptr("www.bing.com"),
// 		ProbePath: to.Ptr("/image"),
// 		QueryStringCachingBehavior: to.Ptr(armcdn.QueryStringCachingBehaviorNotSet),
// 		HostName: to.Ptr("endpoint1.azureedge.net"),
// 		Origins: []*armcdn.DeepCreatedOrigin{
// 			{
// 				Name: to.Ptr("www-bing-com"),
// 				Properties: &armcdn.DeepCreatedOriginProperties{
// 					HostName: to.Ptr("www.bing.com"),
// 					HTTPPort: to.Ptr[int32](80),
// 					HTTPSPort: to.Ptr[int32](443),
// 				},
// 		}},
// 		ProvisioningState: to.Ptr(armcdn.EndpointProvisioningStateSucceeded),
// 		ResourceState: to.Ptr(armcdn.EndpointResourceStateStarting),
// 	},
// }

Output:

func (*EndpointsClient) BeginStop 

func (client *EndpointsClient) BeginStop(ctx context.Context, resourceGroupName string, profileName string, endpointName string, options *EndpointsClientBeginStopOptions) (*runtime.Poller[EndpointsClientStopResponse], error)

BeginStop - Stops an existing running CDN endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • options - EndpointsClientBeginStopOptions contains the optional parameters for the EndpointsClient.BeginStop method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Endpoints_Stop.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewEndpointsClient().BeginStop(ctx, "RG", "profile1", "endpoint1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Endpoint = armcdn.Endpoint{
// 	Name: to.Ptr("endpoint4899"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/endpoints"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1"),
// 	Location: to.Ptr("WestUs"),
// 	Tags: map[string]*string{
// 		"kay1": to.Ptr("value1"),
// 	},
// 	Properties: &armcdn.EndpointProperties{
// 		ContentTypesToCompress: []*string{
// 		},
// 		GeoFilters: []*armcdn.GeoFilter{
// 		},
// 		IsCompressionEnabled: to.Ptr(false),
// 		IsHTTPAllowed: to.Ptr(true),
// 		IsHTTPSAllowed: to.Ptr(true),
// 		OptimizationType: to.Ptr(armcdn.OptimizationTypeDynamicSiteAcceleration),
// 		OriginHostHeader: to.Ptr("www.bing.com"),
// 		ProbePath: to.Ptr("/image"),
// 		QueryStringCachingBehavior: to.Ptr(armcdn.QueryStringCachingBehaviorNotSet),
// 		HostName: to.Ptr("endpoint1.azureedge.net"),
// 		Origins: []*armcdn.DeepCreatedOrigin{
// 			{
// 				Name: to.Ptr("www-bing-com"),
// 				Properties: &armcdn.DeepCreatedOriginProperties{
// 					HostName: to.Ptr("www.bing.com"),
// 					HTTPPort: to.Ptr[int32](80),
// 					HTTPSPort: to.Ptr[int32](443),
// 				},
// 		}},
// 		ProvisioningState: to.Ptr(armcdn.EndpointProvisioningStateSucceeded),
// 		ResourceState: to.Ptr(armcdn.EndpointResourceStateStopping),
// 	},
// }

Output:

func (*EndpointsClient) BeginUpdate 

func (client *EndpointsClient) BeginUpdate(ctx context.Context, resourceGroupName string, profileName string, endpointName string, endpointUpdateProperties EndpointUpdateParameters, options *EndpointsClientBeginUpdateOptions) (*runtime.Poller[EndpointsClientUpdateResponse], error)

BeginUpdate - Updates an existing CDN endpoint with the specified endpoint name under the specified subscription, resource group and profile. Only tags can be updated after creating an endpoint. To update origins, use the Update Origin operation. To update origin groups, use the Update Origin group operation. To update custom domains, use the Update Custom Domain operation. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • endpointUpdateProperties - Endpoint update properties
  • options - EndpointsClientBeginUpdateOptions contains the optional parameters for the EndpointsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Endpoints_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewEndpointsClient().BeginUpdate(ctx, "RG", "profile1", "endpoint1", armcdn.EndpointUpdateParameters{
	Tags: map[string]*string{
		"additionalProperties": to.Ptr("Tag1"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Endpoint = armcdn.Endpoint{
// 	Name: to.Ptr("endpoint1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/endpoints"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1"),
// 	Location: to.Ptr("WestCentralUs"),
// 	Tags: map[string]*string{
// 		"additionalProperties": to.Ptr("Tag1"),
// 	},
// 	Properties: &armcdn.EndpointProperties{
// 		ContentTypesToCompress: []*string{
// 		},
// 		DefaultOriginGroup: &armcdn.ResourceReference{
// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/originGroups/originGroup1"),
// 		},
// 		GeoFilters: []*armcdn.GeoFilter{
// 		},
// 		IsCompressionEnabled: to.Ptr(false),
// 		IsHTTPAllowed: to.Ptr(true),
// 		IsHTTPSAllowed: to.Ptr(true),
// 		QueryStringCachingBehavior: to.Ptr(armcdn.QueryStringCachingBehaviorIgnoreQueryString),
// 		HostName: to.Ptr("endpoint1.azureedge.net"),
// 		OriginGroups: []*armcdn.DeepCreatedOriginGroup{
// 			{
// 				Name: to.Ptr("originGroup1"),
// 				Properties: &armcdn.DeepCreatedOriginGroupProperties{
// 					HealthProbeSettings: &armcdn.HealthProbeParameters{
// 						ProbeIntervalInSeconds: to.Ptr[int32](120),
// 						ProbePath: to.Ptr("/health.aspx"),
// 						ProbeProtocol: to.Ptr(armcdn.ProbeProtocolHTTP),
// 						ProbeRequestType: to.Ptr(armcdn.HealthProbeRequestTypeGET),
// 					},
// 					Origins: []*armcdn.ResourceReference{
// 						{
// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/origins/www-bing-com"),
// 					}},
// 				},
// 		}},
// 		Origins: []*armcdn.DeepCreatedOrigin{
// 			{
// 				Name: to.Ptr("www-bing-com"),
// 				Properties: &armcdn.DeepCreatedOriginProperties{
// 					Enabled: to.Ptr(true),
// 					HostName: to.Ptr("www.bing.com"),
// 					HTTPPort: to.Ptr[int32](80),
// 					HTTPSPort: to.Ptr[int32](443),
// 					OriginHostHeader: to.Ptr("www.someDomain2.net"),
// 					Priority: to.Ptr[int32](2),
// 					Weight: to.Ptr[int32](50),
// 				},
// 		}},
// 		ProvisioningState: to.Ptr(armcdn.EndpointProvisioningStateSucceeded),
// 		ResourceState: to.Ptr(armcdn.EndpointResourceStateCreating),
// 	},
// }

Output:

func (*EndpointsClient) Get 

func (client *EndpointsClient) Get(ctx context.Context, resourceGroupName string, profileName string, endpointName string, options *EndpointsClientGetOptions) (EndpointsClientGetResponse, error)

Get - Gets an existing CDN endpoint with the specified endpoint name under the specified subscription, resource group and profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • options - EndpointsClientGetOptions contains the optional parameters for the EndpointsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Endpoints_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewEndpointsClient().Get(ctx, "RG", "profile1", "endpoint1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Endpoint = armcdn.Endpoint{
// 	Name: to.Ptr("endpoint1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/endpoints"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1"),
// 	Location: to.Ptr("CentralUs"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armcdn.EndpointProperties{
// 		ContentTypesToCompress: []*string{
// 		},
// 		DefaultOriginGroup: &armcdn.ResourceReference{
// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/originGroups/originGroup1"),
// 		},
// 		GeoFilters: []*armcdn.GeoFilter{
// 		},
// 		IsCompressionEnabled: to.Ptr(false),
// 		IsHTTPAllowed: to.Ptr(true),
// 		IsHTTPSAllowed: to.Ptr(true),
// 		OptimizationType: to.Ptr(armcdn.OptimizationTypeDynamicSiteAcceleration),
// 		OriginHostHeader: to.Ptr("www.bing.com"),
// 		ProbePath: to.Ptr("/image"),
// 		QueryStringCachingBehavior: to.Ptr(armcdn.QueryStringCachingBehaviorNotSet),
// 		CustomDomains: []*armcdn.DeepCreatedCustomDomain{
// 			{
// 				Name: to.Ptr("www-someDomain-net"),
// 				Properties: &armcdn.DeepCreatedCustomDomainProperties{
// 					HostName: to.Ptr("www.someDomain.Net"),
// 				},
// 		}},
// 		HostName: to.Ptr("endpoint1.azureedge.net"),
// 		OriginGroups: []*armcdn.DeepCreatedOriginGroup{
// 			{
// 				Name: to.Ptr("originGroup1"),
// 				Properties: &armcdn.DeepCreatedOriginGroupProperties{
// 					HealthProbeSettings: &armcdn.HealthProbeParameters{
// 						ProbeIntervalInSeconds: to.Ptr[int32](120),
// 						ProbePath: to.Ptr("/health.aspx"),
// 						ProbeProtocol: to.Ptr(armcdn.ProbeProtocolHTTP),
// 						ProbeRequestType: to.Ptr(armcdn.HealthProbeRequestTypeGET),
// 					},
// 					Origins: []*armcdn.ResourceReference{
// 						{
// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/origins/www-bing-com"),
// 					}},
// 				},
// 		}},
// 		Origins: []*armcdn.DeepCreatedOrigin{
// 			{
// 				Name: to.Ptr("www-bing-com"),
// 				Properties: &armcdn.DeepCreatedOriginProperties{
// 					Enabled: to.Ptr(true),
// 					HostName: to.Ptr("www.bing.com"),
// 					HTTPPort: to.Ptr[int32](80),
// 					HTTPSPort: to.Ptr[int32](443),
// 					OriginHostHeader: to.Ptr("www.someDomain2.net"),
// 					Priority: to.Ptr[int32](2),
// 					Weight: to.Ptr[int32](50),
// 				},
// 		}},
// 		ProvisioningState: to.Ptr(armcdn.EndpointProvisioningStateSucceeded),
// 		ResourceState: to.Ptr(armcdn.EndpointResourceStateRunning),
// 	},
// }

Output:

func (*EndpointsClient) NewListByProfilePager 

func (client *EndpointsClient) NewListByProfilePager(resourceGroupName string, profileName string, options *EndpointsClientListByProfileOptions) *runtime.Pager[EndpointsClientListByProfileResponse]

NewListByProfilePager - Lists existing CDN endpoints.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • options - EndpointsClientListByProfileOptions contains the optional parameters for the EndpointsClient.NewListByProfilePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Endpoints_ListByProfile.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewEndpointsClient().NewListByProfilePager("RG", "profile1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.EndpointListResult = armcdn.EndpointListResult{
	// 	Value: []*armcdn.Endpoint{
	// 		{
	// 			Name: to.Ptr("endpoint1"),
	// 			Type: to.Ptr("Microsoft.Cdn/profiles/endpoints"),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1"),
	// 			Location: to.Ptr("CentralUs"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Properties: &armcdn.EndpointProperties{
	// 				ContentTypesToCompress: []*string{
	// 				},
	// 				DefaultOriginGroup: &armcdn.ResourceReference{
	// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/originGroups/originGroup1"),
	// 				},
	// 				GeoFilters: []*armcdn.GeoFilter{
	// 				},
	// 				IsCompressionEnabled: to.Ptr(false),
	// 				IsHTTPAllowed: to.Ptr(true),
	// 				IsHTTPSAllowed: to.Ptr(true),
	// 				OptimizationType: to.Ptr(armcdn.OptimizationTypeDynamicSiteAcceleration),
	// 				OriginHostHeader: to.Ptr("www.bing.com"),
	// 				ProbePath: to.Ptr("/image"),
	// 				QueryStringCachingBehavior: to.Ptr(armcdn.QueryStringCachingBehaviorNotSet),
	// 				CustomDomains: []*armcdn.DeepCreatedCustomDomain{
	// 					{
	// 						Name: to.Ptr("www-someDomain-net"),
	// 						Properties: &armcdn.DeepCreatedCustomDomainProperties{
	// 							HostName: to.Ptr("www.someDomain.Net"),
	// 						},
	// 				}},
	// 				HostName: to.Ptr("endpoint1.azureedge.net"),
	// 				OriginGroups: []*armcdn.DeepCreatedOriginGroup{
	// 					{
	// 						Name: to.Ptr("originGroup1"),
	// 						Properties: &armcdn.DeepCreatedOriginGroupProperties{
	// 							HealthProbeSettings: &armcdn.HealthProbeParameters{
	// 								ProbeIntervalInSeconds: to.Ptr[int32](120),
	// 								ProbePath: to.Ptr("/health.aspx"),
	// 								ProbeProtocol: to.Ptr(armcdn.ProbeProtocolHTTP),
	// 								ProbeRequestType: to.Ptr(armcdn.HealthProbeRequestTypeGET),
	// 							},
	// 							Origins: []*armcdn.ResourceReference{
	// 								{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/origins/www-bing-com"),
	// 							}},
	// 							ResponseBasedOriginErrorDetectionSettings: &armcdn.ResponseBasedOriginErrorDetectionParameters{
	// 								ResponseBasedDetectedErrorTypes: to.Ptr(armcdn.ResponseBasedDetectedErrorTypesTCPErrorsOnly),
	// 								ResponseBasedFailoverThresholdPercentage: to.Ptr[int32](10),
	// 							},
	// 						},
	// 				}},
	// 				Origins: []*armcdn.DeepCreatedOrigin{
	// 					{
	// 						Name: to.Ptr("www-bing-com"),
	// 						Properties: &armcdn.DeepCreatedOriginProperties{
	// 							Enabled: to.Ptr(true),
	// 							HostName: to.Ptr("www.bing.com"),
	// 							HTTPPort: to.Ptr[int32](80),
	// 							HTTPSPort: to.Ptr[int32](443),
	// 							OriginHostHeader: to.Ptr("www.someDomain2.net"),
	// 							Priority: to.Ptr[int32](2),
	// 							Weight: to.Ptr[int32](50),
	// 						},
	// 				}},
	// 				ProvisioningState: to.Ptr(armcdn.EndpointProvisioningStateSucceeded),
	// 				ResourceState: to.Ptr(armcdn.EndpointResourceStateRunning),
	// 			},
	// 	}},
	// }
}

Output:

func (*EndpointsClient) NewListResourceUsagePager 

func (client *EndpointsClient) NewListResourceUsagePager(resourceGroupName string, profileName string, endpointName string, options *EndpointsClientListResourceUsageOptions) *runtime.Pager[EndpointsClientListResourceUsageResponse]

NewListResourceUsagePager - Checks the quota and usage of geo filters and custom domains under the given endpoint.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • options - EndpointsClientListResourceUsageOptions contains the optional parameters for the EndpointsClient.NewListResourceUsagePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Endpoints_ListResourceUsage.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewEndpointsClient().NewListResourceUsagePager("RG", "profile1", "endpoint1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.ResourceUsageListResult = armcdn.ResourceUsageListResult{
	// 	Value: []*armcdn.ResourceUsage{
	// 		{
	// 			CurrentValue: to.Ptr[int32](1),
	// 			Limit: to.Ptr[int32](20),
	// 			ResourceType: to.Ptr("customdomain"),
	// 			Unit: to.Ptr(armcdn.ResourceUsageUnitCount),
	// 		},
	// 		{
	// 			CurrentValue: to.Ptr[int32](0),
	// 			Limit: to.Ptr[int32](25),
	// 			ResourceType: to.Ptr("geofilter"),
	// 			Unit: to.Ptr(armcdn.ResourceUsageUnitCount),
	// 	}},
	// }
}

Output:

func (*EndpointsClient) ValidateCustomDomain 

func (client *EndpointsClient) ValidateCustomDomain(ctx context.Context, resourceGroupName string, profileName string, endpointName string, customDomainProperties ValidateCustomDomainInput, options *EndpointsClientValidateCustomDomainOptions) (EndpointsClientValidateCustomDomainResponse, error)

ValidateCustomDomain - Validates the custom domain mapping to ensure it maps to the correct CDN endpoint in DNS. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • customDomainProperties - Custom domain to be validated.
  • options - EndpointsClientValidateCustomDomainOptions contains the optional parameters for the EndpointsClient.ValidateCustomDomain method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Endpoints_ValidateCustomDomain.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewEndpointsClient().ValidateCustomDomain(ctx, "RG", "profile1", "endpoint1", armcdn.ValidateCustomDomainInput{
	HostName: to.Ptr("www.someDomain.com"),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ValidateCustomDomainOutput = armcdn.ValidateCustomDomainOutput{
// 	CustomDomainValidated: to.Ptr(true),
// }

Output:

type EndpointsClientBeginCreateOptions 

type EndpointsClientBeginCreateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

EndpointsClientBeginCreateOptions contains the optional parameters for the EndpointsClient.BeginCreate method.

type EndpointsClientBeginDeleteOptions 

type EndpointsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

EndpointsClientBeginDeleteOptions contains the optional parameters for the EndpointsClient.BeginDelete method.

type EndpointsClientBeginLoadContentOptions 

type EndpointsClientBeginLoadContentOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

EndpointsClientBeginLoadContentOptions contains the optional parameters for the EndpointsClient.BeginLoadContent method.

type EndpointsClientBeginPurgeContentOptions 

type EndpointsClientBeginPurgeContentOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

EndpointsClientBeginPurgeContentOptions contains the optional parameters for the EndpointsClient.BeginPurgeContent method.

type EndpointsClientBeginStartOptions 

type EndpointsClientBeginStartOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

EndpointsClientBeginStartOptions contains the optional parameters for the EndpointsClient.BeginStart method.

type EndpointsClientBeginStopOptions 

type EndpointsClientBeginStopOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

EndpointsClientBeginStopOptions contains the optional parameters for the EndpointsClient.BeginStop method.

type EndpointsClientBeginUpdateOptions 

type EndpointsClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

EndpointsClientBeginUpdateOptions contains the optional parameters for the EndpointsClient.BeginUpdate method.

type EndpointsClientCreateResponse 

type EndpointsClientCreateResponse struct {
	// CDN endpoint is the entity within a CDN profile containing configuration information such as origin, protocol, content
	// caching and delivery behavior. The CDN endpoint uses the URL format <endpointname>.azureedge.net.
	Endpoint
}

EndpointsClientCreateResponse contains the response from method EndpointsClient.BeginCreate.

type EndpointsClientDeleteResponse 

type EndpointsClientDeleteResponse struct {
}

EndpointsClientDeleteResponse contains the response from method EndpointsClient.BeginDelete.

type EndpointsClientGetOptions 

type EndpointsClientGetOptions struct {
}

EndpointsClientGetOptions contains the optional parameters for the EndpointsClient.Get method.

type EndpointsClientGetResponse 

type EndpointsClientGetResponse struct {
	// CDN endpoint is the entity within a CDN profile containing configuration information such as origin, protocol, content
	// caching and delivery behavior. The CDN endpoint uses the URL format <endpointname>.azureedge.net.
	Endpoint
}

EndpointsClientGetResponse contains the response from method EndpointsClient.Get.

type EndpointsClientListByProfileOptions 

type EndpointsClientListByProfileOptions struct {
}

EndpointsClientListByProfileOptions contains the optional parameters for the EndpointsClient.NewListByProfilePager method.

type EndpointsClientListByProfileResponse 

type EndpointsClientListByProfileResponse struct {
	// Result of the request to list endpoints. It contains a list of endpoint objects and a URL link to get the next set of results.
	EndpointListResult
}

EndpointsClientListByProfileResponse contains the response from method EndpointsClient.NewListByProfilePager.

type EndpointsClientListResourceUsageOptions 

type EndpointsClientListResourceUsageOptions struct {
}

EndpointsClientListResourceUsageOptions contains the optional parameters for the EndpointsClient.NewListResourceUsagePager method.

type EndpointsClientListResourceUsageResponse 

type EndpointsClientListResourceUsageResponse struct {
	// Output of check resource usage API.
	ResourceUsageListResult
}

EndpointsClientListResourceUsageResponse contains the response from method EndpointsClient.NewListResourceUsagePager.

type EndpointsClientLoadContentResponse 

type EndpointsClientLoadContentResponse struct {
}

EndpointsClientLoadContentResponse contains the response from method EndpointsClient.BeginLoadContent.

type EndpointsClientPurgeContentResponse 

type EndpointsClientPurgeContentResponse struct {
}

EndpointsClientPurgeContentResponse contains the response from method EndpointsClient.BeginPurgeContent.

type EndpointsClientStartResponse 

type EndpointsClientStartResponse struct {
	// CDN endpoint is the entity within a CDN profile containing configuration information such as origin, protocol, content
	// caching and delivery behavior. The CDN endpoint uses the URL format <endpointname>.azureedge.net.
	Endpoint
}

EndpointsClientStartResponse contains the response from method EndpointsClient.BeginStart.

type EndpointsClientStopResponse 

type EndpointsClientStopResponse struct {
	// CDN endpoint is the entity within a CDN profile containing configuration information such as origin, protocol, content
	// caching and delivery behavior. The CDN endpoint uses the URL format <endpointname>.azureedge.net.
	Endpoint
}

EndpointsClientStopResponse contains the response from method EndpointsClient.BeginStop.

type EndpointsClientUpdateResponse 

type EndpointsClientUpdateResponse struct {
	// CDN endpoint is the entity within a CDN profile containing configuration information such as origin, protocol, content
	// caching and delivery behavior. The CDN endpoint uses the URL format <endpointname>.azureedge.net.
	Endpoint
}

EndpointsClientUpdateResponse contains the response from method EndpointsClient.BeginUpdate.

type EndpointsClientValidateCustomDomainOptions 

type EndpointsClientValidateCustomDomainOptions struct {
}

EndpointsClientValidateCustomDomainOptions contains the optional parameters for the EndpointsClient.ValidateCustomDomain method.

type EndpointsClientValidateCustomDomainResponse 

type EndpointsClientValidateCustomDomainResponse struct {
	// Output of custom domain validation.
	ValidateCustomDomainOutput
}

EndpointsClientValidateCustomDomainResponse contains the response from method EndpointsClient.ValidateCustomDomain.

type ForwardingProtocol 

type ForwardingProtocol string

ForwardingProtocol - Protocol this rule will use when forwarding traffic to backends. 

const (
	ForwardingProtocolHTTPOnly     ForwardingProtocol = "HttpOnly"
	ForwardingProtocolHTTPSOnly    ForwardingProtocol = "HttpsOnly"
	ForwardingProtocolMatchRequest ForwardingProtocol = "MatchRequest"
)

func PossibleForwardingProtocolValues 

func PossibleForwardingProtocolValues() []ForwardingProtocol

PossibleForwardingProtocolValues returns the possible values for the ForwardingProtocol const type.

type GeoFilter 

type GeoFilter struct {
	// REQUIRED; Action of the geo filter, i.e. allow or block access.
	Action *GeoFilterActions

	// REQUIRED; Two letter country or region codes defining user country or region access in a geo filter, e.g. AU, MX, US.
	CountryCodes []*string

	// REQUIRED; Relative path applicable to geo filter. (e.g. '/mypictures', '/mypicture/kitty.jpg', and etc.)
	RelativePath *string
}

GeoFilter - Rules defining user's geo access within a CDN endpoint.

func (GeoFilter) MarshalJSON 

func (g GeoFilter) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type GeoFilter.

func (*GeoFilter) UnmarshalJSON 

func (g *GeoFilter) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type GeoFilter.

type GeoFilterActions 

type GeoFilterActions string

GeoFilterActions - Action of the geo filter, i.e. allow or block access. 

const (
	GeoFilterActionsAllow GeoFilterActions = "Allow"
	GeoFilterActionsBlock GeoFilterActions = "Block"
)

func PossibleGeoFilterActionsValues 

func PossibleGeoFilterActionsValues() []GeoFilterActions

PossibleGeoFilterActionsValues returns the possible values for the GeoFilterActions const type.

type HTTPErrorRangeParameters 

type HTTPErrorRangeParameters struct {
	// The inclusive start of the http status code range.
	Begin *int32

	// The inclusive end of the http status code range.
	End *int32
}

HTTPErrorRangeParameters - The JSON object that represents the range for http status codes

func (HTTPErrorRangeParameters) MarshalJSON 

func (h HTTPErrorRangeParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type HTTPErrorRangeParameters.

func (*HTTPErrorRangeParameters) UnmarshalJSON 

func (h *HTTPErrorRangeParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type HTTPErrorRangeParameters.

type HTTPSRedirect 

type HTTPSRedirect string

HTTPSRedirect - Whether to automatically redirect HTTP traffic to HTTPS traffic. Note that this is a easy way to set up this rule and it will be the first rule that gets executed. 

const (
	HTTPSRedirectDisabled HTTPSRedirect = "Disabled"
	HTTPSRedirectEnabled  HTTPSRedirect = "Enabled"
)

func PossibleHTTPSRedirectValues 

func PossibleHTTPSRedirectValues() []HTTPSRedirect

PossibleHTTPSRedirectValues returns the possible values for the HTTPSRedirect const type.

type HTTPVersionMatchConditionParameters 

type HTTPVersionMatchConditionParameters struct {
	// REQUIRED; Describes operator to be matched
	Operator *HTTPVersionOperator

	// REQUIRED
	TypeName *HTTPVersionMatchConditionParametersTypeName

	// The match value for the condition of the delivery rule
	MatchValues []*string

	// Describes if this is negate condition or not
	NegateCondition *bool

	// List of transforms
	Transforms []*Transform
}

HTTPVersionMatchConditionParameters - Defines the parameters for HttpVersion match conditions

func (HTTPVersionMatchConditionParameters) MarshalJSON 

func (h HTTPVersionMatchConditionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type HTTPVersionMatchConditionParameters.

func (*HTTPVersionMatchConditionParameters) UnmarshalJSON 

func (h *HTTPVersionMatchConditionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type HTTPVersionMatchConditionParameters.

type HTTPVersionMatchConditionParametersTypeName 

type HTTPVersionMatchConditionParametersTypeName string
const (
	HTTPVersionMatchConditionParametersTypeNameDeliveryRuleHTTPVersionConditionParameters HTTPVersionMatchConditionParametersTypeName = "DeliveryRuleHttpVersionConditionParameters"
)

func PossibleHTTPVersionMatchConditionParametersTypeNameValues 

func PossibleHTTPVersionMatchConditionParametersTypeNameValues() []HTTPVersionMatchConditionParametersTypeName

PossibleHTTPVersionMatchConditionParametersTypeNameValues returns the possible values for the HTTPVersionMatchConditionParametersTypeName const type.

type HTTPVersionOperator 

type HTTPVersionOperator string

HTTPVersionOperator - Describes operator to be matched 

const (
	HTTPVersionOperatorEqual HTTPVersionOperator = "Equal"
)

func PossibleHTTPVersionOperatorValues 

func PossibleHTTPVersionOperatorValues() []HTTPVersionOperator

PossibleHTTPVersionOperatorValues returns the possible values for the HTTPVersionOperator const type.

type HeaderAction 

type HeaderAction string

HeaderAction - Action to perform 

const (
	HeaderActionAppend    HeaderAction = "Append"
	HeaderActionDelete    HeaderAction = "Delete"
	HeaderActionOverwrite HeaderAction = "Overwrite"
)

func PossibleHeaderActionValues 

func PossibleHeaderActionValues() []HeaderAction

PossibleHeaderActionValues returns the possible values for the HeaderAction const type.

type HeaderActionParameters 

type HeaderActionParameters struct {
	// REQUIRED; Action to perform
	HeaderAction *HeaderAction

	// REQUIRED; Name of the header to modify
	HeaderName *string

	// REQUIRED
	TypeName *HeaderActionParametersTypeName

	// Value for the specified action
	Value *string
}

HeaderActionParameters - Defines the parameters for the request header action.

func (HeaderActionParameters) MarshalJSON 

func (h HeaderActionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type HeaderActionParameters.

func (*HeaderActionParameters) UnmarshalJSON 

func (h *HeaderActionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type HeaderActionParameters.

type HeaderActionParametersTypeName 

type HeaderActionParametersTypeName string
const (
	HeaderActionParametersTypeNameDeliveryRuleHeaderActionParameters HeaderActionParametersTypeName = "DeliveryRuleHeaderActionParameters"
)

func PossibleHeaderActionParametersTypeNameValues 

func PossibleHeaderActionParametersTypeNameValues() []HeaderActionParametersTypeName

PossibleHeaderActionParametersTypeNameValues returns the possible values for the HeaderActionParametersTypeName const type.

type HealthProbeParameters 

type HealthProbeParameters struct {
	// The number of seconds between health probes.Default is 240sec.
	ProbeIntervalInSeconds *int32

	// The path relative to the origin that is used to determine the health of the origin.
	ProbePath *string

	// Protocol to use for health probe.
	ProbeProtocol *ProbeProtocol

	// The type of health probe request that is made.
	ProbeRequestType *HealthProbeRequestType
}

HealthProbeParameters - The JSON object that contains the properties to send health probes to origin.

func (HealthProbeParameters) MarshalJSON 

func (h HealthProbeParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type HealthProbeParameters.

func (*HealthProbeParameters) UnmarshalJSON 

func (h *HealthProbeParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type HealthProbeParameters.

type HealthProbeRequestType 

type HealthProbeRequestType string

HealthProbeRequestType - The type of health probe request that is made. 

const (
	HealthProbeRequestTypeGET    HealthProbeRequestType = "GET"
	HealthProbeRequestTypeHEAD   HealthProbeRequestType = "HEAD"
	HealthProbeRequestTypeNotSet HealthProbeRequestType = "NotSet"
)

func PossibleHealthProbeRequestTypeValues 

func PossibleHealthProbeRequestTypeValues() []HealthProbeRequestType

PossibleHealthProbeRequestTypeValues returns the possible values for the HealthProbeRequestType const type.

type HostNameMatchConditionParameters 

type HostNameMatchConditionParameters struct {
	// REQUIRED; Describes operator to be matched
	Operator *HostNameOperator

	// REQUIRED
	TypeName *HostNameMatchConditionParametersTypeName

	// The match value for the condition of the delivery rule
	MatchValues []*string

	// Describes if this is negate condition or not
	NegateCondition *bool

	// List of transforms
	Transforms []*Transform
}

HostNameMatchConditionParameters - Defines the parameters for HostName match conditions

func (HostNameMatchConditionParameters) MarshalJSON 

func (h HostNameMatchConditionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type HostNameMatchConditionParameters.

func (*HostNameMatchConditionParameters) UnmarshalJSON 

func (h *HostNameMatchConditionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type HostNameMatchConditionParameters.

type HostNameMatchConditionParametersTypeName 

type HostNameMatchConditionParametersTypeName string
const (
	HostNameMatchConditionParametersTypeNameDeliveryRuleHostNameConditionParameters HostNameMatchConditionParametersTypeName = "DeliveryRuleHostNameConditionParameters"
)

func PossibleHostNameMatchConditionParametersTypeNameValues 

func PossibleHostNameMatchConditionParametersTypeNameValues() []HostNameMatchConditionParametersTypeName

PossibleHostNameMatchConditionParametersTypeNameValues returns the possible values for the HostNameMatchConditionParametersTypeName const type.

type HostNameOperator 

type HostNameOperator string

HostNameOperator - Describes operator to be matched 

const (
	HostNameOperatorAny                HostNameOperator = "Any"
	HostNameOperatorBeginsWith         HostNameOperator = "BeginsWith"
	HostNameOperatorContains           HostNameOperator = "Contains"
	HostNameOperatorEndsWith           HostNameOperator = "EndsWith"
	HostNameOperatorEqual              HostNameOperator = "Equal"
	HostNameOperatorGreaterThan        HostNameOperator = "GreaterThan"
	HostNameOperatorGreaterThanOrEqual HostNameOperator = "GreaterThanOrEqual"
	HostNameOperatorLessThan           HostNameOperator = "LessThan"
	HostNameOperatorLessThanOrEqual    HostNameOperator = "LessThanOrEqual"
	HostNameOperatorRegEx              HostNameOperator = "RegEx"
)

func PossibleHostNameOperatorValues 

func PossibleHostNameOperatorValues() []HostNameOperator

PossibleHostNameOperatorValues returns the possible values for the HostNameOperator const type.

type IPAddressGroup 

type IPAddressGroup struct {
	// The delivery region of the ip address group
	DeliveryRegion *string

	// The list of ip v4 addresses.
	IPv4Addresses []*CidrIPAddress

	// The list of ip v6 addresses.
	IPv6Addresses []*CidrIPAddress
}

IPAddressGroup - CDN Ip address group

func (IPAddressGroup) MarshalJSON 

func (i IPAddressGroup) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPAddressGroup.

func (*IPAddressGroup) UnmarshalJSON 

func (i *IPAddressGroup) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPAddressGroup.

type IdentityType 

type IdentityType string

IdentityType - The type of identity that creates/modifies resources 

const (
	IdentityTypeApplication     IdentityType = "application"
	IdentityTypeKey             IdentityType = "key"
	IdentityTypeManagedIdentity IdentityType = "managedIdentity"
	IdentityTypeUser            IdentityType = "user"
)

func PossibleIdentityTypeValues 

func PossibleIdentityTypeValues() []IdentityType

PossibleIdentityTypeValues returns the possible values for the IdentityType const type.

type IsDeviceMatchConditionParameters 

type IsDeviceMatchConditionParameters struct {
	// REQUIRED; Describes operator to be matched
	Operator *IsDeviceOperator

	// REQUIRED
	TypeName *IsDeviceMatchConditionParametersTypeName

	// The match value for the condition of the delivery rule
	MatchValues []*IsDeviceMatchConditionParametersMatchValuesItem

	// Describes if this is negate condition or not
	NegateCondition *bool

	// List of transforms
	Transforms []*Transform
}

IsDeviceMatchConditionParameters - Defines the parameters for IsDevice match conditions

func (IsDeviceMatchConditionParameters) MarshalJSON 

func (i IsDeviceMatchConditionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IsDeviceMatchConditionParameters.

func (*IsDeviceMatchConditionParameters) UnmarshalJSON 

func (i *IsDeviceMatchConditionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IsDeviceMatchConditionParameters.

type IsDeviceMatchConditionParametersMatchValuesItem 

type IsDeviceMatchConditionParametersMatchValuesItem string
const (
	IsDeviceMatchConditionParametersMatchValuesItemDesktop IsDeviceMatchConditionParametersMatchValuesItem = "Desktop"
	IsDeviceMatchConditionParametersMatchValuesItemMobile  IsDeviceMatchConditionParametersMatchValuesItem = "Mobile"
)

func PossibleIsDeviceMatchConditionParametersMatchValuesItemValues 

func PossibleIsDeviceMatchConditionParametersMatchValuesItemValues() []IsDeviceMatchConditionParametersMatchValuesItem

PossibleIsDeviceMatchConditionParametersMatchValuesItemValues returns the possible values for the IsDeviceMatchConditionParametersMatchValuesItem const type.

type IsDeviceMatchConditionParametersTypeName 

type IsDeviceMatchConditionParametersTypeName string
const (
	IsDeviceMatchConditionParametersTypeNameDeliveryRuleIsDeviceConditionParameters IsDeviceMatchConditionParametersTypeName = "DeliveryRuleIsDeviceConditionParameters"
)

func PossibleIsDeviceMatchConditionParametersTypeNameValues 

func PossibleIsDeviceMatchConditionParametersTypeNameValues() []IsDeviceMatchConditionParametersTypeName

PossibleIsDeviceMatchConditionParametersTypeNameValues returns the possible values for the IsDeviceMatchConditionParametersTypeName const type.

type IsDeviceOperator 

type IsDeviceOperator string

IsDeviceOperator - Describes operator to be matched 

const (
	IsDeviceOperatorEqual IsDeviceOperator = "Equal"
)

func PossibleIsDeviceOperatorValues 

func PossibleIsDeviceOperatorValues() []IsDeviceOperator

PossibleIsDeviceOperatorValues returns the possible values for the IsDeviceOperator const type.

type KeyVaultCertificateSourceParameters 

type KeyVaultCertificateSourceParameters struct {
	// REQUIRED; Describes the action that shall be taken when the certificate is removed from Key Vault.
	DeleteRule *DeleteRule

	// REQUIRED; Resource group of the user's Key Vault containing the SSL certificate
	ResourceGroupName *string

	// REQUIRED; The name of Key Vault Secret (representing the full certificate PFX) in Key Vault.
	SecretName *string

	// REQUIRED; Subscription Id of the user's Key Vault containing the SSL certificate
	SubscriptionID *string

	// REQUIRED
	TypeName *KeyVaultCertificateSourceParametersTypeName

	// REQUIRED; Describes the action that shall be taken when the certificate is updated in Key Vault.
	UpdateRule *UpdateRule

	// REQUIRED; The name of the user's Key Vault containing the SSL certificate
	VaultName *string

	// The version(GUID) of Key Vault Secret in Key Vault.
	SecretVersion *string
}

KeyVaultCertificateSourceParameters - Describes the parameters for using a user's KeyVault certificate for securing custom domain.

func (KeyVaultCertificateSourceParameters) MarshalJSON 

func (k KeyVaultCertificateSourceParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type KeyVaultCertificateSourceParameters.

func (*KeyVaultCertificateSourceParameters) UnmarshalJSON 

func (k *KeyVaultCertificateSourceParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type KeyVaultCertificateSourceParameters.

type KeyVaultCertificateSourceParametersTypeName 

type KeyVaultCertificateSourceParametersTypeName string
const (
	KeyVaultCertificateSourceParametersTypeNameKeyVaultCertificateSourceParameters KeyVaultCertificateSourceParametersTypeName = "KeyVaultCertificateSourceParameters"
)

func PossibleKeyVaultCertificateSourceParametersTypeNameValues 

func PossibleKeyVaultCertificateSourceParametersTypeNameValues() []KeyVaultCertificateSourceParametersTypeName

PossibleKeyVaultCertificateSourceParametersTypeNameValues returns the possible values for the KeyVaultCertificateSourceParametersTypeName const type.

type KeyVaultSigningKeyParameters 

type KeyVaultSigningKeyParameters struct {
	// REQUIRED; Resource group of the user's Key Vault containing the secret
	ResourceGroupName *string

	// REQUIRED; The name of secret in Key Vault.
	SecretName *string

	// REQUIRED; The version(GUID) of secret in Key Vault.
	SecretVersion *string

	// REQUIRED; Subscription Id of the user's Key Vault containing the secret
	SubscriptionID *string

	// REQUIRED
	TypeName *KeyVaultSigningKeyParametersTypeName

	// REQUIRED; The name of the user's Key Vault containing the secret
	VaultName *string
}

KeyVaultSigningKeyParameters - Describes the parameters for using a user's KeyVault for URL Signing Key.

func (KeyVaultSigningKeyParameters) MarshalJSON 

func (k KeyVaultSigningKeyParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type KeyVaultSigningKeyParameters.

func (*KeyVaultSigningKeyParameters) UnmarshalJSON 

func (k *KeyVaultSigningKeyParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type KeyVaultSigningKeyParameters.

type KeyVaultSigningKeyParametersTypeName 

type KeyVaultSigningKeyParametersTypeName string
const (
	KeyVaultSigningKeyParametersTypeNameKeyVaultSigningKeyParameters KeyVaultSigningKeyParametersTypeName = "KeyVaultSigningKeyParameters"
)

func PossibleKeyVaultSigningKeyParametersTypeNameValues 

func PossibleKeyVaultSigningKeyParametersTypeNameValues() []KeyVaultSigningKeyParametersTypeName

PossibleKeyVaultSigningKeyParametersTypeNameValues returns the possible values for the KeyVaultSigningKeyParametersTypeName const type.

type LinkToDefaultDomain 

type LinkToDefaultDomain string

LinkToDefaultDomain - whether this route will be linked to the default endpoint domain. 

const (
	LinkToDefaultDomainDisabled LinkToDefaultDomain = "Disabled"
	LinkToDefaultDomainEnabled  LinkToDefaultDomain = "Enabled"
)

func PossibleLinkToDefaultDomainValues 

func PossibleLinkToDefaultDomainValues() []LinkToDefaultDomain

PossibleLinkToDefaultDomainValues returns the possible values for the LinkToDefaultDomain const type.

type LinkedEndpoint 

type LinkedEndpoint struct {
	// ARM Resource ID string.
	ID *string
}

LinkedEndpoint - Defines the ARM Resource ID for the linked endpoints

func (LinkedEndpoint) MarshalJSON 

func (l LinkedEndpoint) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LinkedEndpoint.

func (*LinkedEndpoint) UnmarshalJSON 

func (l *LinkedEndpoint) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LinkedEndpoint.

type LoadBalancingSettingsParameters 

type LoadBalancingSettingsParameters struct {
	// The additional latency in milliseconds for probes to fall into the lowest latency bucket
	AdditionalLatencyInMilliseconds *int32

	// The number of samples to consider for load balancing decisions
	SampleSize *int32

	// The number of samples within the sample period that must succeed
	SuccessfulSamplesRequired *int32
}

LoadBalancingSettingsParameters - Round-Robin load balancing settings for a backend pool

func (LoadBalancingSettingsParameters) MarshalJSON 

func (l LoadBalancingSettingsParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LoadBalancingSettingsParameters.

func (*LoadBalancingSettingsParameters) UnmarshalJSON 

func (l *LoadBalancingSettingsParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LoadBalancingSettingsParameters.

type LoadParameters 

type LoadParameters struct {
	// REQUIRED; The path to the content to be loaded. Path should be a relative file URL of the origin.
	ContentPaths []*string
}

LoadParameters - Parameters required for content load.

func (LoadParameters) MarshalJSON 

func (l LoadParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LoadParameters.

func (*LoadParameters) UnmarshalJSON 

func (l *LoadParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LoadParameters.

type LogAnalyticsClient 

type LogAnalyticsClient struct {
	// contains filtered or unexported fields
}

LogAnalyticsClient contains the methods for the LogAnalytics group. Don't use this type directly, use NewLogAnalyticsClient() instead.

func NewLogAnalyticsClient 

func NewLogAnalyticsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*LogAnalyticsClient, error)

NewLogAnalyticsClient creates a new instance of LogAnalyticsClient with the specified values.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*LogAnalyticsClient) GetLogAnalyticsLocations 

func (client *LogAnalyticsClient) GetLogAnalyticsLocations(ctx context.Context, resourceGroupName string, profileName string, options *LogAnalyticsClientGetLogAnalyticsLocationsOptions) (LogAnalyticsClientGetLogAnalyticsLocationsResponse, error)

GetLogAnalyticsLocations - Get all available location names for AFD log analytics report. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group. which is unique within the resource group.
  • options - LogAnalyticsClientGetLogAnalyticsLocationsOptions contains the optional parameters for the LogAnalyticsClient.GetLogAnalyticsLocations method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/LogAnalytics_GetLogAnalyticsLocations.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewLogAnalyticsClient().GetLogAnalyticsLocations(ctx, "RG", "profile1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ContinentsResponse = armcdn.ContinentsResponse{
// 	Continents: []*armcdn.ContinentsResponseContinentsItem{
// 		{
// 			ID: to.Ptr("africa"),
// 		},
// 		{
// 			ID: to.Ptr("antarctica"),
// 		},
// 		{
// 			ID: to.Ptr("asia"),
// 		},
// 		{
// 			ID: to.Ptr("europe"),
// 		},
// 		{
// 			ID: to.Ptr("northAmerica"),
// 		},
// 		{
// 			ID: to.Ptr("oceania"),
// 		},
// 		{
// 			ID: to.Ptr("southAmerica"),
// 	}},
// 	CountryOrRegions: []*armcdn.ContinentsResponseCountryOrRegionsItem{
// 		{
// 			ContinentID: to.Ptr("africa"),
// 			ID: to.Ptr("dz"),
// 		},
// 		{
// 			ContinentID: to.Ptr("africa"),
// 			ID: to.Ptr("ao"),
// 		},
// 		{
// 			ContinentID: to.Ptr("africa"),
// 			ID: to.Ptr("bw"),
// 		},
// 		{
// 			ContinentID: to.Ptr("africa"),
// 			ID: to.Ptr("bi"),
// 	}},
// }

Output:

func (*LogAnalyticsClient) GetLogAnalyticsMetrics 

func (client *LogAnalyticsClient) GetLogAnalyticsMetrics(ctx context.Context, resourceGroupName string, profileName string, metrics []LogMetric, dateTimeBegin time.Time, dateTimeEnd time.Time, granularity LogMetricsGranularity, customDomains []string, protocols []string, options *LogAnalyticsClientGetLogAnalyticsMetricsOptions) (LogAnalyticsClientGetLogAnalyticsMetricsResponse, error)

GetLogAnalyticsMetrics - Get log report for AFD profile If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group. which is unique within the resource group.
  • options - LogAnalyticsClientGetLogAnalyticsMetricsOptions contains the optional parameters for the LogAnalyticsClient.GetLogAnalyticsMetrics method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/LogAnalytics_GetLogAnalyticsMetrics.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewLogAnalyticsClient().GetLogAnalyticsMetrics(ctx, "RG", "profile1", []armcdn.LogMetric{
	armcdn.LogMetricClientRequestCount}, func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T04:30:00.000Z"); return t }(), func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T05:00:00.000Z"); return t }(), armcdn.LogMetricsGranularityPT5M, []string{
	"customdomain1.azurecdn.net",
	"customdomain2.azurecdn.net"}, []string{
	"https"}, &armcdn.LogAnalyticsClientGetLogAnalyticsMetricsOptions{GroupBy: []armcdn.LogMetricsGroupBy{
	armcdn.LogMetricsGroupByProtocol},
	Continents:       []string{},
	CountryOrRegions: []string{},
})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.MetricsResponse = armcdn.MetricsResponse{
// 	DateTimeBegin: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T04:30:27.554Z"); return t}()),
// 	DateTimeEnd: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T05:00:27.554Z"); return t}()),
// 	Granularity: to.Ptr(armcdn.MetricsGranularityPT5M),
// 	Series: []*armcdn.MetricsResponseSeriesItem{
// 		{
// 			Data: []*armcdn.Components1Gs0LlpSchemasMetricsresponsePropertiesSeriesItemsPropertiesDataItems{
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T04:35:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](4250),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T04:40:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](3120),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T04:45:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](2221),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T04:50:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](2466),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T04:55:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](2654),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T05:00:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](3565),
// 			}},
// 			Groups: []*armcdn.MetricsResponseSeriesPropertiesItemsItem{
// 				{
// 					Name: to.Ptr("protocol"),
// 					Value: to.Ptr("https"),
// 			}},
// 			Metric: to.Ptr("clientRequestCount"),
// 			Unit: to.Ptr(armcdn.MetricsSeriesUnitCount),
// 	}},
// }

Output:

func (*LogAnalyticsClient) GetLogAnalyticsRankings 

func (client *LogAnalyticsClient) GetLogAnalyticsRankings(ctx context.Context, resourceGroupName string, profileName string, rankings []LogRanking, metrics []LogRankingMetric, maxRanking int32, dateTimeBegin time.Time, dateTimeEnd time.Time, options *LogAnalyticsClientGetLogAnalyticsRankingsOptions) (LogAnalyticsClientGetLogAnalyticsRankingsResponse, error)

GetLogAnalyticsRankings - Get log analytics ranking report for AFD profile If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group. which is unique within the resource group.
  • options - LogAnalyticsClientGetLogAnalyticsRankingsOptions contains the optional parameters for the LogAnalyticsClient.GetLogAnalyticsRankings method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/LogAnalytics_GetLogAnalyticsRankings.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewLogAnalyticsClient().GetLogAnalyticsRankings(ctx, "RG", "profile1", []armcdn.LogRanking{
	armcdn.LogRankingURL}, []armcdn.LogRankingMetric{
	armcdn.LogRankingMetricClientRequestCount}, 5, func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T06:49:27.554Z"); return t }(), func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T09:49:27.554Z"); return t }(), &armcdn.LogAnalyticsClientGetLogAnalyticsRankingsOptions{CustomDomains: []string{}})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.RankingsResponse = armcdn.RankingsResponse{
// 	DateTimeBegin: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T06:49:27.554Z"); return t}()),
// 	DateTimeEnd: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T09:49:27.554Z"); return t}()),
// 	Tables: []*armcdn.RankingsResponseTablesItem{
// 		{
// 			Data: []*armcdn.RankingsResponseTablesPropertiesItemsItem{
// 				{
// 					Name: to.Ptr("https://testdomain.com/favicon.png"),
// 					Metrics: []*armcdn.RankingsResponseTablesPropertiesItemsMetricsItem{
// 						{
// 							Metric: to.Ptr("clientRequestCount"),
// 							Percentage: to.Ptr[float32](8.28133862733976),
// 							Value: to.Ptr[int64](2336),
// 					}},
// 				},
// 				{
// 					Name: to.Ptr("https://testdomain.com/js/app.js"),
// 					Metrics: []*armcdn.RankingsResponseTablesPropertiesItemsMetricsItem{
// 						{
// 							Metric: to.Ptr("clientRequestCount"),
// 							Percentage: to.Ptr[float32](7.586500283607488),
// 							Value: to.Ptr[int64](2140),
// 					}},
// 				},
// 				{
// 					Name: to.Ptr("https://testdomain.com/js/lang/en.js"),
// 					Metrics: []*armcdn.RankingsResponseTablesPropertiesItemsMetricsItem{
// 						{
// 							Metric: to.Ptr("clientRequestCount"),
// 							Percentage: to.Ptr[float32](5.445263754963131),
// 							Value: to.Ptr[int64](1536),
// 					}},
// 				},
// 				{
// 					Name: to.Ptr("https://testdomain.com/js/lib.js"),
// 					Metrics: []*armcdn.RankingsResponseTablesPropertiesItemsMetricsItem{
// 						{
// 							Metric: to.Ptr("clientRequestCount"),
// 							Percentage: to.Ptr[float32](5.246738513896767),
// 							Value: to.Ptr[int64](1480),
// 					}},
// 				},
// 				{
// 					Name: to.Ptr("https://cdn.exam.net/css/lib.css"),
// 					Metrics: []*armcdn.RankingsResponseTablesPropertiesItemsMetricsItem{
// 						{
// 							Metric: to.Ptr("clientRequestCount"),
// 							Percentage: to.Ptr[float32](5.147475893363584),
// 							Value: to.Ptr[int64](1452),
// 					}},
// 			}},
// 			Ranking: to.Ptr("url"),
// 	}},
// }

Output:

func (*LogAnalyticsClient) GetLogAnalyticsResources 

func (client *LogAnalyticsClient) GetLogAnalyticsResources(ctx context.Context, resourceGroupName string, profileName string, options *LogAnalyticsClientGetLogAnalyticsResourcesOptions) (LogAnalyticsClientGetLogAnalyticsResourcesResponse, error)

GetLogAnalyticsResources - Get all endpoints and custom domains available for AFD log report If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group. which is unique within the resource group.
  • options - LogAnalyticsClientGetLogAnalyticsResourcesOptions contains the optional parameters for the LogAnalyticsClient.GetLogAnalyticsResources method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/LogAnalytics_GetLogAnalyticsResources.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewLogAnalyticsClient().GetLogAnalyticsResources(ctx, "RG", "profile1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ResourcesResponse = armcdn.ResourcesResponse{
// 	CustomDomains: []*armcdn.ResourcesResponseCustomDomainsItem{
// 		{
// 			Name: to.Ptr("customdomain1.azurecdn.net"),
// 			History: to.Ptr(true),
// 			ID: to.Ptr("customdomain1.azurecdn.net"),
// 		},
// 		{
// 			Name: to.Ptr("customdomain2.azurecdn.net"),
// 			History: to.Ptr(true),
// 			ID: to.Ptr("customdomain2.azurecdn.net"),
// 		},
// 		{
// 			Name: to.Ptr("customdomain3.azurecdn.net"),
// 			History: to.Ptr(true),
// 			ID: to.Ptr("customdomain3.azurecdn.net"),
// 	}},
// 	Endpoints: []*armcdn.ResourcesResponseEndpointsItem{
// 		{
// 			Name: to.Ptr("endpoint1.azureedge.net"),
// 			CustomDomains: []*armcdn.ResourcesResponseEndpointsPropertiesItemsItem{
// 				{
// 					Name: to.Ptr("customdomain1.azurecdn.net"),
// 					EndpointID: to.Ptr("enbdpiont1"),
// 					History: to.Ptr(true),
// 					ID: to.Ptr("customdomain1.azurecdn.net"),
// 				},
// 				{
// 					Name: to.Ptr("customdomain2.azurecdn.net"),
// 					History: to.Ptr(true),
// 					ID: to.Ptr("customdomain2.azurecdn.net"),
// 			}},
// 			History: to.Ptr(false),
// 			ID: to.Ptr("endpoint1"),
// 	}},
// }

Output:

func (*LogAnalyticsClient) GetWafLogAnalyticsMetrics 

func (client *LogAnalyticsClient) GetWafLogAnalyticsMetrics(ctx context.Context, resourceGroupName string, profileName string, metrics []WafMetric, dateTimeBegin time.Time, dateTimeEnd time.Time, granularity WafGranularity, options *LogAnalyticsClientGetWafLogAnalyticsMetricsOptions) (LogAnalyticsClientGetWafLogAnalyticsMetricsResponse, error)

GetWafLogAnalyticsMetrics - Get Waf related log analytics report for AFD profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group. which is unique within the resource group.
  • options - LogAnalyticsClientGetWafLogAnalyticsMetricsOptions contains the optional parameters for the LogAnalyticsClient.GetWafLogAnalyticsMetrics method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/LogAnalytics_GetWafLogAnalyticsMetrics.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewLogAnalyticsClient().GetWafLogAnalyticsMetrics(ctx, "RG", "profile1", []armcdn.WafMetric{
	armcdn.WafMetricClientRequestCount}, func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T06:49:27.554Z"); return t }(), func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T09:49:27.554Z"); return t }(), armcdn.WafGranularityPT5M, &armcdn.LogAnalyticsClientGetWafLogAnalyticsMetricsOptions{Actions: []armcdn.WafAction{
	armcdn.WafActionBlock,
	armcdn.WafActionLog},
	GroupBy:   []armcdn.WafRankingGroupBy{},
	RuleTypes: []armcdn.WafRuleType{},
})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.WafMetricsResponse = armcdn.WafMetricsResponse{
// 	DateTimeBegin: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T06:30:27.554Z"); return t}()),
// 	DateTimeEnd: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T09:00:27.554Z"); return t}()),
// 	Granularity: to.Ptr(armcdn.WafMetricsGranularityPT5M),
// 	Series: []*armcdn.WafMetricsResponseSeriesItem{
// 		{
// 			Data: []*armcdn.Components18OrqelSchemasWafmetricsresponsePropertiesSeriesItemsPropertiesDataItems{
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T07:05:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](2),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T07:10:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](32),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T07:15:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](31),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T07:20:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](63),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T07:25:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](50),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T07:30:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](12),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T07:35:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](8),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T07:40:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](21),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T07:45:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](30),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T07:50:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](18),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T07:55:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](28),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T08:00:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](3),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T08:05:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](58),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T08:10:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](42),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T08:15:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](17),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T08:20:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](21),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T08:25:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](41),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T08:30:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](8),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T08:35:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](15),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T08:40:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](25),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T08:45:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](13),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T08:50:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](17),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T08:55:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](29),
// 				},
// 				{
// 					DateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T09:00:00.000Z"); return t}()),
// 					Value: to.Ptr[float32](17),
// 			}},
// 			Groups: []*armcdn.WafMetricsResponseSeriesPropertiesItemsItem{
// 			},
// 			Metric: to.Ptr("clientRequestCount"),
// 			Unit: to.Ptr(armcdn.WafMetricsSeriesUnitCount),
// 	}},
// }

Output:

func (*LogAnalyticsClient) GetWafLogAnalyticsRankings 

func (client *LogAnalyticsClient) GetWafLogAnalyticsRankings(ctx context.Context, resourceGroupName string, profileName string, metrics []WafMetric, dateTimeBegin time.Time, dateTimeEnd time.Time, maxRanking int32, rankings []WafRankingType, options *LogAnalyticsClientGetWafLogAnalyticsRankingsOptions) (LogAnalyticsClientGetWafLogAnalyticsRankingsResponse, error)

GetWafLogAnalyticsRankings - Get WAF log analytics charts for AFD profile If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group. which is unique within the resource group.
  • options - LogAnalyticsClientGetWafLogAnalyticsRankingsOptions contains the optional parameters for the LogAnalyticsClient.GetWafLogAnalyticsRankings method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/LogAnalytics_GetWafLogAnalyticsRankings.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewLogAnalyticsClient().GetWafLogAnalyticsRankings(ctx, "RG", "profile1", []armcdn.WafMetric{
	armcdn.WafMetricClientRequestCount}, func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T06:49:27.554Z"); return t }(), func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T09:49:27.554Z"); return t }(), 5, []armcdn.WafRankingType{
	armcdn.WafRankingTypeRuleID}, &armcdn.LogAnalyticsClientGetWafLogAnalyticsRankingsOptions{Actions: []armcdn.WafAction{},
	RuleTypes: []armcdn.WafRuleType{},
})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.WafRankingsResponse = armcdn.WafRankingsResponse{
// 	Data: []*armcdn.WafRankingsResponseDataItem{
// 		{
// 			GroupValues: []*string{
// 				to.Ptr("BlockRateLimit")},
// 				Metrics: []*armcdn.ComponentsKpo1PjSchemasWafrankingsresponsePropertiesDataItemsPropertiesMetricsItems{
// 					{
// 						Metric: to.Ptr("clientRequestCount"),
// 						Percentage: to.Ptr[float64](0),
// 						Value: to.Ptr[int64](1268),
// 				}},
// 		}},
// 		DateTimeBegin: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T06:49:27.554Z"); return t}()),
// 		DateTimeEnd: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-04T09:49:27.554Z"); return t}()),
// 		Groups: []*string{
// 			to.Ptr("ruleId")},
// 		}

Output:

type LogAnalyticsClientGetLogAnalyticsLocationsOptions 

type LogAnalyticsClientGetLogAnalyticsLocationsOptions struct {
}

LogAnalyticsClientGetLogAnalyticsLocationsOptions contains the optional parameters for the LogAnalyticsClient.GetLogAnalyticsLocations method.

type LogAnalyticsClientGetLogAnalyticsLocationsResponse 

type LogAnalyticsClientGetLogAnalyticsLocationsResponse struct {
	// Continents Response
	ContinentsResponse
}

LogAnalyticsClientGetLogAnalyticsLocationsResponse contains the response from method LogAnalyticsClient.GetLogAnalyticsLocations.

type LogAnalyticsClientGetLogAnalyticsMetricsOptions 

type LogAnalyticsClientGetLogAnalyticsMetricsOptions struct {
	Continents       []string
	CountryOrRegions []string
	GroupBy          []LogMetricsGroupBy
}

LogAnalyticsClientGetLogAnalyticsMetricsOptions contains the optional parameters for the LogAnalyticsClient.GetLogAnalyticsMetrics method.

type LogAnalyticsClientGetLogAnalyticsMetricsResponse 

type LogAnalyticsClientGetLogAnalyticsMetricsResponse struct {
	// Metrics Response
	MetricsResponse
}

LogAnalyticsClientGetLogAnalyticsMetricsResponse contains the response from method LogAnalyticsClient.GetLogAnalyticsMetrics.

type LogAnalyticsClientGetLogAnalyticsRankingsOptions 

type LogAnalyticsClientGetLogAnalyticsRankingsOptions struct {
	CustomDomains []string
}

LogAnalyticsClientGetLogAnalyticsRankingsOptions contains the optional parameters for the LogAnalyticsClient.GetLogAnalyticsRankings method.

type LogAnalyticsClientGetLogAnalyticsRankingsResponse 

type LogAnalyticsClientGetLogAnalyticsRankingsResponse struct {
	// Rankings Response
	RankingsResponse
}

LogAnalyticsClientGetLogAnalyticsRankingsResponse contains the response from method LogAnalyticsClient.GetLogAnalyticsRankings.

type LogAnalyticsClientGetLogAnalyticsResourcesOptions 

type LogAnalyticsClientGetLogAnalyticsResourcesOptions struct {
}

LogAnalyticsClientGetLogAnalyticsResourcesOptions contains the optional parameters for the LogAnalyticsClient.GetLogAnalyticsResources method.

type LogAnalyticsClientGetLogAnalyticsResourcesResponse 

type LogAnalyticsClientGetLogAnalyticsResourcesResponse struct {
	// Resources Response
	ResourcesResponse
}

LogAnalyticsClientGetLogAnalyticsResourcesResponse contains the response from method LogAnalyticsClient.GetLogAnalyticsResources.

type LogAnalyticsClientGetWafLogAnalyticsMetricsOptions 

type LogAnalyticsClientGetWafLogAnalyticsMetricsOptions struct {
	Actions   []WafAction
	GroupBy   []WafRankingGroupBy
	RuleTypes []WafRuleType
}

LogAnalyticsClientGetWafLogAnalyticsMetricsOptions contains the optional parameters for the LogAnalyticsClient.GetWafLogAnalyticsMetrics method.

type LogAnalyticsClientGetWafLogAnalyticsMetricsResponse 

type LogAnalyticsClientGetWafLogAnalyticsMetricsResponse struct {
	// Waf Metrics Response
	WafMetricsResponse
}

LogAnalyticsClientGetWafLogAnalyticsMetricsResponse contains the response from method LogAnalyticsClient.GetWafLogAnalyticsMetrics.

type LogAnalyticsClientGetWafLogAnalyticsRankingsOptions 

type LogAnalyticsClientGetWafLogAnalyticsRankingsOptions struct {
	Actions   []WafAction
	RuleTypes []WafRuleType
}

LogAnalyticsClientGetWafLogAnalyticsRankingsOptions contains the optional parameters for the LogAnalyticsClient.GetWafLogAnalyticsRankings method.

type LogAnalyticsClientGetWafLogAnalyticsRankingsResponse 

type LogAnalyticsClientGetWafLogAnalyticsRankingsResponse struct {
	// Waf Rankings Response
	WafRankingsResponse
}

LogAnalyticsClientGetWafLogAnalyticsRankingsResponse contains the response from method LogAnalyticsClient.GetWafLogAnalyticsRankings.

type LogMetric 

type LogMetric string
const (
	LogMetricClientRequestBandwidth LogMetric = "clientRequestBandwidth"
	LogMetricClientRequestCount     LogMetric = "clientRequestCount"
	LogMetricClientRequestTraffic   LogMetric = "clientRequestTraffic"
	LogMetricOriginRequestBandwidth LogMetric = "originRequestBandwidth"
	LogMetricOriginRequestTraffic   LogMetric = "originRequestTraffic"
	LogMetricTotalLatency           LogMetric = "totalLatency"
)

func PossibleLogMetricValues 

func PossibleLogMetricValues() []LogMetric

PossibleLogMetricValues returns the possible values for the LogMetric const type.

type LogMetricsGranularity 

type LogMetricsGranularity string
const (
	LogMetricsGranularityP1D  LogMetricsGranularity = "P1D"
	LogMetricsGranularityPT1H LogMetricsGranularity = "PT1H"
	LogMetricsGranularityPT5M LogMetricsGranularity = "PT5M"
)

func PossibleLogMetricsGranularityValues 

func PossibleLogMetricsGranularityValues() []LogMetricsGranularity

PossibleLogMetricsGranularityValues returns the possible values for the LogMetricsGranularity const type.

type LogMetricsGroupBy 

type LogMetricsGroupBy string
const (
	LogMetricsGroupByCacheStatus     LogMetricsGroupBy = "cacheStatus"
	LogMetricsGroupByCountryOrRegion LogMetricsGroupBy = "countryOrRegion"
	LogMetricsGroupByCustomDomain    LogMetricsGroupBy = "customDomain"
	LogMetricsGroupByHTTPStatusCode  LogMetricsGroupBy = "httpStatusCode"
	LogMetricsGroupByProtocol        LogMetricsGroupBy = "protocol"
)

func PossibleLogMetricsGroupByValues 

func PossibleLogMetricsGroupByValues() []LogMetricsGroupBy

PossibleLogMetricsGroupByValues returns the possible values for the LogMetricsGroupBy const type.

type LogRanking 

type LogRanking string
const (
	LogRankingBrowser         LogRanking = "browser"
	LogRankingCountryOrRegion LogRanking = "countryOrRegion"
	LogRankingReferrer        LogRanking = "referrer"
	LogRankingURL             LogRanking = "url"
	LogRankingUserAgent       LogRanking = "userAgent"
)

func PossibleLogRankingValues 

func PossibleLogRankingValues() []LogRanking

PossibleLogRankingValues returns the possible values for the LogRanking const type.

type LogRankingMetric 

type LogRankingMetric string
const (
	LogRankingMetricClientRequestCount   LogRankingMetric = "clientRequestCount"
	LogRankingMetricClientRequestTraffic LogRankingMetric = "clientRequestTraffic"
	LogRankingMetricErrorCount           LogRankingMetric = "errorCount"
	LogRankingMetricHitCount             LogRankingMetric = "hitCount"
	LogRankingMetricMissCount            LogRankingMetric = "missCount"
	LogRankingMetricUserErrorCount       LogRankingMetric = "userErrorCount"
)

func PossibleLogRankingMetricValues 

func PossibleLogRankingMetricValues() []LogRankingMetric

PossibleLogRankingMetricValues returns the possible values for the LogRankingMetric const type.

type LogSpecification 

type LogSpecification struct {
	// Blob duration of specification.
	BlobDuration *string

	// Display name of log specification.
	DisplayName *string

	// Pattern to filter based on name
	LogFilterPattern *string

	// Name of log specification.
	Name *string
}

LogSpecification - Log specification of operation.

func (LogSpecification) MarshalJSON 

func (l LogSpecification) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LogSpecification.

func (*LogSpecification) UnmarshalJSON 

func (l *LogSpecification) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LogSpecification.

type ManagedCertificateParameters 

type ManagedCertificateParameters struct {
	// REQUIRED; The type of the secret resource.
	Type *SecretType

	// READ-ONLY; Certificate expiration date.
	ExpirationDate *string

	// READ-ONLY; Subject name in the certificate.
	Subject *string
}

ManagedCertificateParameters - Managed Certificate used for https

func (*ManagedCertificateParameters) GetSecretParameters 

func (m *ManagedCertificateParameters) GetSecretParameters() *SecretParameters

GetSecretParameters implements the SecretParametersClassification interface for type ManagedCertificateParameters.

func (ManagedCertificateParameters) MarshalJSON 

func (m ManagedCertificateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedCertificateParameters.

func (*ManagedCertificateParameters) UnmarshalJSON 

func (m *ManagedCertificateParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedCertificateParameters.

type ManagedHTTPSParameters 

type ManagedHTTPSParameters struct {
	// REQUIRED; Defines the source of the SSL certificate.
	CertificateSource *CertificateSource

	// REQUIRED; Defines the certificate source parameters using CDN managed certificate for enabling SSL.
	CertificateSourceParameters *CertificateSourceParameters

	// REQUIRED; Defines the TLS extension protocol that is used for secure delivery.
	ProtocolType *ProtocolType

	// TLS protocol version that will be used for Https
	MinimumTLSVersion *MinimumTLSVersion
}

ManagedHTTPSParameters - Defines the certificate source parameters using CDN managed certificate for enabling SSL.

func (*ManagedHTTPSParameters) GetCustomDomainHTTPSParameters 

func (m *ManagedHTTPSParameters) GetCustomDomainHTTPSParameters() *CustomDomainHTTPSParameters

GetCustomDomainHTTPSParameters implements the CustomDomainHTTPSParametersClassification interface for type ManagedHTTPSParameters.

func (ManagedHTTPSParameters) MarshalJSON 

func (m ManagedHTTPSParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedHTTPSParameters.

func (*ManagedHTTPSParameters) UnmarshalJSON 

func (m *ManagedHTTPSParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedHTTPSParameters.

type ManagedRuleDefinition 

type ManagedRuleDefinition struct {
	// READ-ONLY; Describes the functionality of the managed rule.
	Description *string

	// READ-ONLY; Identifier for the managed rule.
	RuleID *string
}

ManagedRuleDefinition - Describes a managed rule definition.

func (ManagedRuleDefinition) MarshalJSON 

func (m ManagedRuleDefinition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedRuleDefinition.

func (*ManagedRuleDefinition) UnmarshalJSON 

func (m *ManagedRuleDefinition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedRuleDefinition.

type ManagedRuleEnabledState 

type ManagedRuleEnabledState string

ManagedRuleEnabledState - Describes if the managed rule is in enabled or disabled state. Defaults to Disabled if not specified. 

const (
	ManagedRuleEnabledStateDisabled ManagedRuleEnabledState = "Disabled"
	ManagedRuleEnabledStateEnabled  ManagedRuleEnabledState = "Enabled"
)

func PossibleManagedRuleEnabledStateValues 

func PossibleManagedRuleEnabledStateValues() []ManagedRuleEnabledState

PossibleManagedRuleEnabledStateValues returns the possible values for the ManagedRuleEnabledState const type.

type ManagedRuleGroupDefinition 

type ManagedRuleGroupDefinition struct {
	// READ-ONLY; Description of the managed rule group.
	Description *string

	// READ-ONLY; Name of the managed rule group.
	RuleGroupName *string

	// READ-ONLY; List of rules within the managed rule group.
	Rules []*ManagedRuleDefinition
}

ManagedRuleGroupDefinition - Describes a managed rule group.

func (ManagedRuleGroupDefinition) MarshalJSON 

func (m ManagedRuleGroupDefinition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedRuleGroupDefinition.

func (*ManagedRuleGroupDefinition) UnmarshalJSON 

func (m *ManagedRuleGroupDefinition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedRuleGroupDefinition.

type ManagedRuleGroupOverride 

type ManagedRuleGroupOverride struct {
	// REQUIRED; Describes the managed rule group within the rule set to override
	RuleGroupName *string

	// List of rules that will be enabled. If none specified, all rules in the group will be disabled.
	Rules []*ManagedRuleOverride
}

ManagedRuleGroupOverride - Defines a managed rule group override setting.

func (ManagedRuleGroupOverride) MarshalJSON 

func (m ManagedRuleGroupOverride) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedRuleGroupOverride.

func (*ManagedRuleGroupOverride) UnmarshalJSON 

func (m *ManagedRuleGroupOverride) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedRuleGroupOverride.

type ManagedRuleOverride 

type ManagedRuleOverride struct {
	// REQUIRED; Identifier for the managed rule.
	RuleID *string

	// Describes the override action to be applied when rule matches.
	Action *ActionType

	// Describes if the managed rule is in enabled or disabled state. Defaults to Disabled if not specified.
	EnabledState *ManagedRuleEnabledState
}

ManagedRuleOverride - Defines a managed rule group override setting.

func (ManagedRuleOverride) MarshalJSON 

func (m ManagedRuleOverride) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedRuleOverride.

func (*ManagedRuleOverride) UnmarshalJSON 

func (m *ManagedRuleOverride) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedRuleOverride.

type ManagedRuleSet 

type ManagedRuleSet struct {
	// REQUIRED; Defines the rule set type to use.
	RuleSetType *string

	// REQUIRED; Defines the version of the rule set to use.
	RuleSetVersion *string

	// Verizon only : If the rule set supports anomaly detection mode, this describes the threshold for blocking requests.
	AnomalyScore *int32

	// Defines the rule overrides to apply to the rule set.
	RuleGroupOverrides []*ManagedRuleGroupOverride
}

ManagedRuleSet - Defines a managed rule set.

func (ManagedRuleSet) MarshalJSON 

func (m ManagedRuleSet) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedRuleSet.

func (*ManagedRuleSet) UnmarshalJSON 

func (m *ManagedRuleSet) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedRuleSet.

type ManagedRuleSetDefinition 

type ManagedRuleSetDefinition struct {
	// Describes managed rule set definition properties.
	Properties *ManagedRuleSetDefinitionProperties

	// The pricing tier (defines a CDN provider, feature list and rate) of the CdnWebApplicationFirewallPolicy.
	SKU *SKU

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Read only system data
	SystemData *SystemData

	// READ-ONLY; Resource type.
	Type *string
}

ManagedRuleSetDefinition - Describes a managed rule set definition.

func (ManagedRuleSetDefinition) MarshalJSON 

func (m ManagedRuleSetDefinition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedRuleSetDefinition.

func (*ManagedRuleSetDefinition) UnmarshalJSON 

func (m *ManagedRuleSetDefinition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedRuleSetDefinition.

type ManagedRuleSetDefinitionList 

type ManagedRuleSetDefinitionList struct {
	// URL to retrieve next set of managed rule set definitions.
	NextLink *string

	// READ-ONLY; List of managed rule set definitions.
	Value []*ManagedRuleSetDefinition
}

ManagedRuleSetDefinitionList - List of managed rule set definitions available for use in a policy.

func (ManagedRuleSetDefinitionList) MarshalJSON 

func (m ManagedRuleSetDefinitionList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedRuleSetDefinitionList.

func (*ManagedRuleSetDefinitionList) UnmarshalJSON 

func (m *ManagedRuleSetDefinitionList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedRuleSetDefinitionList.

type ManagedRuleSetDefinitionProperties 

type ManagedRuleSetDefinitionProperties struct {
	// READ-ONLY; Provisioning state of the managed rule set.
	ProvisioningState *string

	// READ-ONLY; Rule groups of the managed rule set.
	RuleGroups []*ManagedRuleGroupDefinition

	// READ-ONLY; Type of the managed rule set.
	RuleSetType *string

	// READ-ONLY; Version of the managed rule set type.
	RuleSetVersion *string
}

ManagedRuleSetDefinitionProperties - Properties for a managed rule set definition.

func (ManagedRuleSetDefinitionProperties) MarshalJSON 

func (m ManagedRuleSetDefinitionProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedRuleSetDefinitionProperties.

func (*ManagedRuleSetDefinitionProperties) UnmarshalJSON 

func (m *ManagedRuleSetDefinitionProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedRuleSetDefinitionProperties.

type ManagedRuleSetList 

type ManagedRuleSetList struct {
	// List of rule sets.
	ManagedRuleSets []*ManagedRuleSet
}

ManagedRuleSetList - Defines the list of managed rule sets for the policy.

func (ManagedRuleSetList) MarshalJSON 

func (m ManagedRuleSetList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedRuleSetList.

func (*ManagedRuleSetList) UnmarshalJSON 

func (m *ManagedRuleSetList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedRuleSetList.

type ManagedRuleSetsClient 

type ManagedRuleSetsClient struct {
	// contains filtered or unexported fields
}

ManagedRuleSetsClient contains the methods for the ManagedRuleSets group. Don't use this type directly, use NewManagedRuleSetsClient() instead.

func NewManagedRuleSetsClient 

func NewManagedRuleSetsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ManagedRuleSetsClient, error)

NewManagedRuleSetsClient creates a new instance of ManagedRuleSetsClient with the specified values.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ManagedRuleSetsClient) NewListPager 

func (client *ManagedRuleSetsClient) NewListPager(options *ManagedRuleSetsClientListOptions) *runtime.Pager[ManagedRuleSetsClientListResponse]

NewListPager - Lists all available managed rule sets.

Generated from API version 2024-02-01

  • options - ManagedRuleSetsClientListOptions contains the optional parameters for the ManagedRuleSetsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/WafListManagedRuleSets.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewManagedRuleSetsClient().NewListPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.ManagedRuleSetDefinitionList = armcdn.ManagedRuleSetDefinitionList{
	// 	Value: []*armcdn.ManagedRuleSetDefinition{
	// 		{
	// 			Name: to.Ptr("DefaultRuleSet_1.0"),
	// 			Type: to.Ptr("Microsoft.Cdn/cdnwebapplicationfirewallmanagedrulesets"),
	// 			ID: to.Ptr("/subscriptions/subid/providers/Microsoft.Cdn/CdnWebApplicationFirewallManagedRuleSets"),
	// 			Properties: &armcdn.ManagedRuleSetDefinitionProperties{
	// 				ProvisioningState: to.Ptr("Succeeded"),
	// 				RuleGroups: []*armcdn.ManagedRuleGroupDefinition{
	// 					{
	// 						Description: to.Ptr("Description for rule group 1."),
	// 						RuleGroupName: to.Ptr("Group1"),
	// 						Rules: []*armcdn.ManagedRuleDefinition{
	// 							{
	// 								Description: to.Ptr("Generic managed web application firewall rule."),
	// 								RuleID: to.Ptr("GROUP1-0001"),
	// 							},
	// 							{
	// 								Description: to.Ptr("Generic managed web application firewall rule."),
	// 								RuleID: to.Ptr("GROUP1-0002"),
	// 						}},
	// 					},
	// 					{
	// 						Description: to.Ptr("Description for rule group 2."),
	// 						RuleGroupName: to.Ptr("Group2"),
	// 						Rules: []*armcdn.ManagedRuleDefinition{
	// 							{
	// 								Description: to.Ptr("Generic managed web application firewall rule."),
	// 								RuleID: to.Ptr("GROUP2-0001"),
	// 						}},
	// 				}},
	// 				RuleSetType: to.Ptr("DefaultRuleSet"),
	// 				RuleSetVersion: to.Ptr("preview-1.0"),
	// 			},
	// 			SKU: &armcdn.SKU{
	// 				Name: to.Ptr(armcdn.SKUNameStandardMicrosoft),
	// 			},
	// 	}},
	// }
}

Output:

type ManagedRuleSetsClientListOptions 

type ManagedRuleSetsClientListOptions struct {
}

ManagedRuleSetsClientListOptions contains the optional parameters for the ManagedRuleSetsClient.NewListPager method.

type ManagedRuleSetsClientListResponse 

type ManagedRuleSetsClientListResponse struct {
	// List of managed rule set definitions available for use in a policy.
	ManagedRuleSetDefinitionList
}

ManagedRuleSetsClientListResponse contains the response from method ManagedRuleSetsClient.NewListPager.

type ManagedServiceIdentity 

type ManagedServiceIdentity struct {
	// REQUIRED; Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
	Type *ManagedServiceIdentityType

	// The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM
	// resource ids in the form:
	// '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}.
	// The dictionary values can be empty objects ({}) in
	// requests.
	UserAssignedIdentities map[string]*UserAssignedIdentity

	// READ-ONLY; The service principal ID of the system assigned identity. This property will only be provided for a system assigned
	// identity.
	PrincipalID *string

	// READ-ONLY; The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity.
	TenantID *string
}

ManagedServiceIdentity - Managed service identity (system assigned and/or user assigned identities)

func (ManagedServiceIdentity) MarshalJSON 

func (m ManagedServiceIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedServiceIdentity.

func (*ManagedServiceIdentity) UnmarshalJSON 

func (m *ManagedServiceIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedServiceIdentity.

type ManagedServiceIdentityType 

type ManagedServiceIdentityType string

ManagedServiceIdentityType - Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). 

const (
	ManagedServiceIdentityTypeNone                       ManagedServiceIdentityType = "None"
	ManagedServiceIdentityTypeSystemAssigned             ManagedServiceIdentityType = "SystemAssigned"
	ManagedServiceIdentityTypeSystemAssignedUserAssigned ManagedServiceIdentityType = "SystemAssigned, UserAssigned"
	ManagedServiceIdentityTypeUserAssigned               ManagedServiceIdentityType = "UserAssigned"
)

func PossibleManagedServiceIdentityTypeValues 

func PossibleManagedServiceIdentityTypeValues() []ManagedServiceIdentityType

PossibleManagedServiceIdentityTypeValues returns the possible values for the ManagedServiceIdentityType const type.

type ManagementClient 

type ManagementClient struct {
	// contains filtered or unexported fields
}

ManagementClient contains the methods for the CdnManagementClient group. Don't use this type directly, use NewManagementClient() instead.

func NewManagementClient 

func NewManagementClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ManagementClient, error)

NewManagementClient creates a new instance of ManagementClient with the specified values.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ManagementClient) CheckEndpointNameAvailability 

func (client *ManagementClient) CheckEndpointNameAvailability(ctx context.Context, resourceGroupName string, checkEndpointNameAvailabilityInput CheckEndpointNameAvailabilityInput, options *ManagementClientCheckEndpointNameAvailabilityOptions) (ManagementClientCheckEndpointNameAvailabilityResponse, error)

CheckEndpointNameAvailability - Check the availability of a resource name. This is needed for resources where name is globally unique, such as a afdx endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • checkEndpointNameAvailabilityInput - Input to check.
  • options - ManagementClientCheckEndpointNameAvailabilityOptions contains the optional parameters for the ManagementClient.CheckEndpointNameAvailability method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/CheckEndpointNameAvailability.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewManagementClient().CheckEndpointNameAvailability(ctx, "myResourceGroup", armcdn.CheckEndpointNameAvailabilityInput{
	Name:                              to.Ptr("sampleName"),
	Type:                              to.Ptr(armcdn.ResourceTypeMicrosoftCdnProfilesAfdEndpoints),
	AutoGeneratedDomainNameLabelScope: to.Ptr(armcdn.AutoGeneratedDomainNameLabelScopeTenantReuse),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.CheckEndpointNameAvailabilityOutput = armcdn.CheckEndpointNameAvailabilityOutput{
// 	AvailableHostname: to.Ptr(""),
// 	Message: to.Ptr("Name not available"),
// 	NameAvailable: to.Ptr(false),
// 	Reason: to.Ptr("Name is already in use"),
// }

Output:

func (*ManagementClient) CheckNameAvailability 

func (client *ManagementClient) CheckNameAvailability(ctx context.Context, checkNameAvailabilityInput CheckNameAvailabilityInput, options *ManagementClientCheckNameAvailabilityOptions) (ManagementClientCheckNameAvailabilityResponse, error)

CheckNameAvailability - Check the availability of a resource name. This is needed for resources where name is globally unique, such as a CDN endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • checkNameAvailabilityInput - Input to check.
  • options - ManagementClientCheckNameAvailabilityOptions contains the optional parameters for the ManagementClient.CheckNameAvailability method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/CheckNameAvailability.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewManagementClient().CheckNameAvailability(ctx, armcdn.CheckNameAvailabilityInput{
	Name: to.Ptr("sampleName"),
	Type: to.Ptr(armcdn.ResourceTypeMicrosoftCdnProfilesEndpoints),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.CheckNameAvailabilityOutput = armcdn.CheckNameAvailabilityOutput{
// 	Message: to.Ptr("Name not available"),
// 	NameAvailable: to.Ptr(false),
// 	Reason: to.Ptr("Name is already in use"),
// }

Output:

func (*ManagementClient) CheckNameAvailabilityWithSubscription 

func (client *ManagementClient) CheckNameAvailabilityWithSubscription(ctx context.Context, checkNameAvailabilityInput CheckNameAvailabilityInput, options *ManagementClientCheckNameAvailabilityWithSubscriptionOptions) (ManagementClientCheckNameAvailabilityWithSubscriptionResponse, error)

CheckNameAvailabilityWithSubscription - Check the availability of a resource name. This is needed for resources where name is globally unique, such as a CDN endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • checkNameAvailabilityInput - Input to check.
  • options - ManagementClientCheckNameAvailabilityWithSubscriptionOptions contains the optional parameters for the ManagementClient.CheckNameAvailabilityWithSubscription method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/CheckNameAvailabilityWithSubscription.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewManagementClient().CheckNameAvailabilityWithSubscription(ctx, armcdn.CheckNameAvailabilityInput{
	Name: to.Ptr("sampleName"),
	Type: to.Ptr(armcdn.ResourceTypeMicrosoftCdnProfilesEndpoints),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.CheckNameAvailabilityOutput = armcdn.CheckNameAvailabilityOutput{
// 	Message: to.Ptr("Name not available"),
// 	NameAvailable: to.Ptr(false),
// 	Reason: to.Ptr("Name is already in use"),
// }

Output:

func (*ManagementClient) ValidateProbe 

func (client *ManagementClient) ValidateProbe(ctx context.Context, validateProbeInput ValidateProbeInput, options *ManagementClientValidateProbeOptions) (ManagementClientValidateProbeResponse, error)

ValidateProbe - Check if the probe path is a valid path and the file can be accessed. Probe path is the path to a file hosted on the origin server to help accelerate the delivery of dynamic content via the CDN endpoint. This path is relative to the origin path specified in the endpoint configuration. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • validateProbeInput - Input to check.
  • options - ManagementClientValidateProbeOptions contains the optional parameters for the ManagementClient.ValidateProbe method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/ValidateProbe.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewManagementClient().ValidateProbe(ctx, armcdn.ValidateProbeInput{
	ProbeURL: to.Ptr("https://www.bing.com/image"),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ValidateProbeOutput = armcdn.ValidateProbeOutput{
// 	ErrorCode: to.Ptr("None"),
// 	IsValid: to.Ptr(true),
// }

Output:

type ManagementClientCheckEndpointNameAvailabilityOptions 

type ManagementClientCheckEndpointNameAvailabilityOptions struct {
}

ManagementClientCheckEndpointNameAvailabilityOptions contains the optional parameters for the ManagementClient.CheckEndpointNameAvailability method.

type ManagementClientCheckEndpointNameAvailabilityResponse 

type ManagementClientCheckEndpointNameAvailabilityResponse struct {
	// Output of check name availability API.
	CheckEndpointNameAvailabilityOutput
}

ManagementClientCheckEndpointNameAvailabilityResponse contains the response from method ManagementClient.CheckEndpointNameAvailability.

type ManagementClientCheckNameAvailabilityOptions 

type ManagementClientCheckNameAvailabilityOptions struct {
}

ManagementClientCheckNameAvailabilityOptions contains the optional parameters for the ManagementClient.CheckNameAvailability method.

type ManagementClientCheckNameAvailabilityResponse 

type ManagementClientCheckNameAvailabilityResponse struct {
	// Output of check name availability API.
	CheckNameAvailabilityOutput
}

ManagementClientCheckNameAvailabilityResponse contains the response from method ManagementClient.CheckNameAvailability.

type ManagementClientCheckNameAvailabilityWithSubscriptionOptions 

type ManagementClientCheckNameAvailabilityWithSubscriptionOptions struct {
}

ManagementClientCheckNameAvailabilityWithSubscriptionOptions contains the optional parameters for the ManagementClient.CheckNameAvailabilityWithSubscription method.

type ManagementClientCheckNameAvailabilityWithSubscriptionResponse 

type ManagementClientCheckNameAvailabilityWithSubscriptionResponse struct {
	// Output of check name availability API.
	CheckNameAvailabilityOutput
}

ManagementClientCheckNameAvailabilityWithSubscriptionResponse contains the response from method ManagementClient.CheckNameAvailabilityWithSubscription.

type ManagementClientValidateProbeOptions 

type ManagementClientValidateProbeOptions struct {
}

ManagementClientValidateProbeOptions contains the optional parameters for the ManagementClient.ValidateProbe method.

type ManagementClientValidateProbeResponse 

type ManagementClientValidateProbeResponse struct {
	// Output of the validate probe API.
	ValidateProbeOutput
}

ManagementClientValidateProbeResponse contains the response from method ManagementClient.ValidateProbe.

type MatchCondition 

type MatchCondition struct {
	// REQUIRED; List of possible match values.
	MatchValue []*string

	// REQUIRED; Match variable to compare against.
	MatchVariable *WafMatchVariable

	// REQUIRED; Describes operator to be matched
	Operator *Operator

	// Describes if the result of this condition should be negated.
	NegateCondition *bool

	// Selector can used to match a specific key for QueryString, Cookies, RequestHeader or PostArgs.
	Selector *string

	// List of transforms.
	Transforms []*TransformType
}

MatchCondition - Define match conditions

func (MatchCondition) MarshalJSON 

func (m MatchCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MatchCondition.

func (*MatchCondition) UnmarshalJSON 

func (m *MatchCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MatchCondition.

type MatchProcessingBehavior 

type MatchProcessingBehavior string

MatchProcessingBehavior - If this rule is a match should the rules engine continue running the remaining rules or stop. If not present, defaults to Continue. 

const (
	MatchProcessingBehaviorContinue MatchProcessingBehavior = "Continue"
	MatchProcessingBehaviorStop     MatchProcessingBehavior = "Stop"
)

func PossibleMatchProcessingBehaviorValues 

func PossibleMatchProcessingBehaviorValues() []MatchProcessingBehavior

PossibleMatchProcessingBehaviorValues returns the possible values for the MatchProcessingBehavior const type.

type MatchVariable 

type MatchVariable string

MatchVariable - The name of the condition for the delivery rule. 

const (
	MatchVariableClientPort       MatchVariable = "ClientPort"
	MatchVariableCookies          MatchVariable = "Cookies"
	MatchVariableHTTPVersion      MatchVariable = "HttpVersion"
	MatchVariableHostName         MatchVariable = "HostName"
	MatchVariableIsDevice         MatchVariable = "IsDevice"
	MatchVariablePostArgs         MatchVariable = "PostArgs"
	MatchVariableQueryString      MatchVariable = "QueryString"
	MatchVariableRemoteAddress    MatchVariable = "RemoteAddress"
	MatchVariableRequestBody      MatchVariable = "RequestBody"
	MatchVariableRequestHeader    MatchVariable = "RequestHeader"
	MatchVariableRequestMethod    MatchVariable = "RequestMethod"
	MatchVariableRequestScheme    MatchVariable = "RequestScheme"
	MatchVariableRequestURI       MatchVariable = "RequestUri"
	MatchVariableSSLProtocol      MatchVariable = "SslProtocol"
	MatchVariableServerPort       MatchVariable = "ServerPort"
	MatchVariableSocketAddr       MatchVariable = "SocketAddr"
	MatchVariableURLFileExtension MatchVariable = "UrlFileExtension"
	MatchVariableURLFileName      MatchVariable = "UrlFileName"
	MatchVariableURLPath          MatchVariable = "UrlPath"
)

func PossibleMatchVariableValues 

func PossibleMatchVariableValues() []MatchVariable

PossibleMatchVariableValues returns the possible values for the MatchVariable const type.

type MetricAvailability 

type MetricAvailability struct {
	BlobDuration *string
	TimeGrain    *string
}

MetricAvailability - Retention policy of a resource metric.

func (MetricAvailability) MarshalJSON 

func (m MetricAvailability) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MetricAvailability.

func (*MetricAvailability) UnmarshalJSON 

func (m *MetricAvailability) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MetricAvailability.

type MetricSpecification 

type MetricSpecification struct {
	// The metric aggregation type. Possible values include: 'Average', 'Count', 'Total'.
	AggregationType *string

	// Retention policies of a resource metric.
	Availabilities []*MetricAvailability

	// The dimensions of metric
	Dimensions []*DimensionProperties

	// Display description of metric specification.
	DisplayDescription *string

	// Display name of metric specification.
	DisplayName *string

	// Property to specify whether to fill gap with zero.
	FillGapWithZero *bool

	// Property to specify metric is internal or not.
	IsInternal *bool

	// Pattern to filter based on name
	MetricFilterPattern *string

	// Name of metric specification.
	Name *string

	// The supported time grain types for the metrics.
	SupportedTimeGrainTypes []*string

	// The metric unit. Possible values include: 'Bytes', 'Count', 'Milliseconds'.
	Unit *string
}

MetricSpecification - Metric specification of operation.

func (MetricSpecification) MarshalJSON 

func (m MetricSpecification) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MetricSpecification.

func (*MetricSpecification) UnmarshalJSON 

func (m *MetricSpecification) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MetricSpecification.

type MetricsGranularity 

type MetricsGranularity string
const (
	MetricsGranularityP1D  MetricsGranularity = "P1D"
	MetricsGranularityPT1H MetricsGranularity = "PT1H"
	MetricsGranularityPT5M MetricsGranularity = "PT5M"
)

func PossibleMetricsGranularityValues 

func PossibleMetricsGranularityValues() []MetricsGranularity

PossibleMetricsGranularityValues returns the possible values for the MetricsGranularity const type.

type MetricsResponse 

type MetricsResponse struct {
	DateTimeBegin *time.Time
	DateTimeEnd   *time.Time
	Granularity   *MetricsGranularity
	Series        []*MetricsResponseSeriesItem
}

MetricsResponse - Metrics Response

func (MetricsResponse) MarshalJSON 

func (m MetricsResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MetricsResponse.

func (*MetricsResponse) UnmarshalJSON 

func (m *MetricsResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MetricsResponse.

type MetricsResponseSeriesItem 

type MetricsResponseSeriesItem struct {
	Data   []*Components1Gs0LlpSchemasMetricsresponsePropertiesSeriesItemsPropertiesDataItems
	Groups []*MetricsResponseSeriesPropertiesItemsItem
	Metric *string
	Unit   *MetricsSeriesUnit
}

func (MetricsResponseSeriesItem) MarshalJSON 

func (m MetricsResponseSeriesItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MetricsResponseSeriesItem.

func (*MetricsResponseSeriesItem) UnmarshalJSON 

func (m *MetricsResponseSeriesItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MetricsResponseSeriesItem.

type MetricsResponseSeriesPropertiesItemsItem 

type MetricsResponseSeriesPropertiesItemsItem struct {
	Name  *string
	Value *string
}

func (MetricsResponseSeriesPropertiesItemsItem) MarshalJSON 

func (m MetricsResponseSeriesPropertiesItemsItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MetricsResponseSeriesPropertiesItemsItem.

func (*MetricsResponseSeriesPropertiesItemsItem) UnmarshalJSON 

func (m *MetricsResponseSeriesPropertiesItemsItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MetricsResponseSeriesPropertiesItemsItem.

type MetricsSeriesUnit 

type MetricsSeriesUnit string
const (
	MetricsSeriesUnitBitsPerSecond MetricsSeriesUnit = "bitsPerSecond"
	MetricsSeriesUnitBytes         MetricsSeriesUnit = "bytes"
	MetricsSeriesUnitCount         MetricsSeriesUnit = "count"
	MetricsSeriesUnitMilliSeconds  MetricsSeriesUnit = "milliSeconds"
)

func PossibleMetricsSeriesUnitValues 

func PossibleMetricsSeriesUnitValues() []MetricsSeriesUnit

PossibleMetricsSeriesUnitValues returns the possible values for the MetricsSeriesUnit const type.

type MigrateResult 

type MigrateResult struct {
	Properties *MigrateResultProperties

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource type.
	Type *string
}

MigrateResult - Result for migrate operation.

func (MigrateResult) MarshalJSON 

func (m MigrateResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MigrateResult.

func (*MigrateResult) UnmarshalJSON 

func (m *MigrateResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MigrateResult.

type MigrateResultProperties 

type MigrateResultProperties struct {
	// READ-ONLY; Arm resource id of the migrated profile
	MigratedProfileResourceID *ResourceReference
}

func (MigrateResultProperties) MarshalJSON 

func (m MigrateResultProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MigrateResultProperties.

func (*MigrateResultProperties) UnmarshalJSON 

func (m *MigrateResultProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MigrateResultProperties.

type MigrationErrorType 

type MigrationErrorType struct {
	// READ-ONLY; Error code.
	Code *string

	// READ-ONLY; Error message indicating why the operation failed.
	ErrorMessage *string

	// READ-ONLY; Describes what needs to be done to fix the problem
	NextSteps *string

	// READ-ONLY; Resource which has the problem.
	ResourceName *string
}

MigrationErrorType - Error response indicates CDN service is not able to process the incoming request. The reason is provided in the error message.

func (MigrationErrorType) MarshalJSON 

func (m MigrationErrorType) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MigrationErrorType.

func (*MigrationErrorType) UnmarshalJSON 

func (m *MigrationErrorType) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MigrationErrorType.

type MigrationParameters 

type MigrationParameters struct {
	// REQUIRED; Resource reference of the classic cdn profile or classic frontdoor that need to be migrated.
	ClassicResourceReference *ResourceReference

	// REQUIRED; Name of the new profile that need to be created.
	ProfileName *string

	// REQUIRED; Sku for the migration
	SKU *SKU

	// Waf mapping for the migrated profile
	MigrationWebApplicationFirewallMappings []*MigrationWebApplicationFirewallMapping
}

MigrationParameters - Request body for Migrate operation.

func (MigrationParameters) MarshalJSON 

func (m MigrationParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MigrationParameters.

func (*MigrationParameters) UnmarshalJSON 

func (m *MigrationParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MigrationParameters.

type MigrationWebApplicationFirewallMapping 

type MigrationWebApplicationFirewallMapping struct {
	// Migration From Waf policy
	MigratedFrom *ResourceReference

	// Migration to Waf policy
	MigratedTo *ResourceReference
}

MigrationWebApplicationFirewallMapping - Web Application Firewall Mapping

func (MigrationWebApplicationFirewallMapping) MarshalJSON 

func (m MigrationWebApplicationFirewallMapping) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MigrationWebApplicationFirewallMapping.

func (*MigrationWebApplicationFirewallMapping) UnmarshalJSON 

func (m *MigrationWebApplicationFirewallMapping) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MigrationWebApplicationFirewallMapping.

type MinimumTLSVersion 

type MinimumTLSVersion string

MinimumTLSVersion - TLS protocol version that will be used for Https 

const (
	MinimumTLSVersionNone  MinimumTLSVersion = "None"
	MinimumTLSVersionTLS10 MinimumTLSVersion = "TLS10"
	MinimumTLSVersionTLS12 MinimumTLSVersion = "TLS12"
)

func PossibleMinimumTLSVersionValues 

func PossibleMinimumTLSVersionValues() []MinimumTLSVersion

PossibleMinimumTLSVersionValues returns the possible values for the MinimumTLSVersion const type.

type Operation 

type Operation struct {
	// The object that represents the operation.
	Display *OperationDisplay

	// Indicates whether the operation is a data action
	IsDataAction *bool

	// Properties of operation, include metric specifications.
	OperationProperties *OperationProperties

	// READ-ONLY; Operation name: {provider}/{resource}/{operation}
	Name *string

	// READ-ONLY; The origin of operations.
	Origin *string
}

Operation - CDN REST API operation

func (Operation) MarshalJSON 

func (o Operation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON 

func (o *Operation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Operation.

type OperationDisplay 

type OperationDisplay struct {
	// READ-ONLY; Description of operation.
	Description *string

	// READ-ONLY; Operation type: Read, write, delete, etc.
	Operation *string

	// READ-ONLY; Service provider: Microsoft.Cdn
	Provider *string

	// READ-ONLY; Resource on which the operation is performed: Profile, endpoint, etc.
	Resource *string
}

OperationDisplay - The object that represents the operation.

func (OperationDisplay) MarshalJSON 

func (o OperationDisplay) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON 

func (o *OperationDisplay) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationProperties 

type OperationProperties struct {
	// One property of operation, include metric specifications.
	ServiceSpecification *ServiceSpecification
}

OperationProperties - Properties of operation, include metric specifications.

func (OperationProperties) MarshalJSON 

func (o OperationProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationProperties.

func (*OperationProperties) UnmarshalJSON 

func (o *OperationProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationProperties.

type OperationsClient 

type OperationsClient struct {
	// contains filtered or unexported fields
}

OperationsClient contains the methods for the Operations group. Don't use this type directly, use NewOperationsClient() instead.

func NewOperationsClient 

func NewOperationsClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*OperationsClient, error)

NewOperationsClient creates a new instance of OperationsClient with the specified values.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*OperationsClient) NewListPager 

func (client *OperationsClient) NewListPager(options *OperationsClientListOptions) *runtime.Pager[OperationsClientListResponse]

NewListPager - Lists all of the available CDN REST API operations.

Generated from API version 2024-02-01

  • options - OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Operations_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewOperationsClient().NewListPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.OperationsListResult = armcdn.OperationsListResult{
	// 	Value: []*armcdn.Operation{
	// 		{
	// 			Name: to.Ptr("Microsoft.Cdn/register/action"),
	// 			Display: &armcdn.OperationDisplay{
	// 				Operation: to.Ptr("Registers the Microsoft.Cdn Resource Provider"),
	// 				Provider: to.Ptr("Microsoft.Cdn"),
	// 				Resource: to.Ptr("Microsoft.Cdn Resource Provider"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.Cdn/edgenodes/read"),
	// 			Display: &armcdn.OperationDisplay{
	// 				Operation: to.Ptr("read"),
	// 				Provider: to.Ptr("Microsoft.Cdn"),
	// 				Resource: to.Ptr("EdgeNode"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.Cdn/edgenodes/write"),
	// 			Display: &armcdn.OperationDisplay{
	// 				Operation: to.Ptr("write"),
	// 				Provider: to.Ptr("Microsoft.Cdn"),
	// 				Resource: to.Ptr("EdgeNode"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.Cdn/edgenodes/delete"),
	// 			Display: &armcdn.OperationDisplay{
	// 				Operation: to.Ptr("delete"),
	// 				Provider: to.Ptr("Microsoft.Cdn"),
	// 				Resource: to.Ptr("EdgeNode"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.Cdn/profiles/read"),
	// 			Display: &armcdn.OperationDisplay{
	// 				Operation: to.Ptr("read"),
	// 				Provider: to.Ptr("Microsoft.Cdn"),
	// 				Resource: to.Ptr("Profile"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.Cdn/profiles/write"),
	// 			Display: &armcdn.OperationDisplay{
	// 				Operation: to.Ptr("write"),
	// 				Provider: to.Ptr("Microsoft.Cdn"),
	// 				Resource: to.Ptr("Profile"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.Cdn/operationresults/profileresults/write"),
	// 			Display: &armcdn.OperationDisplay{
	// 				Operation: to.Ptr("write"),
	// 				Provider: to.Ptr("Microsoft.Cdn"),
	// 				Resource: to.Ptr("Profile"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.Cdn/operationresults/profileresults/delete"),
	// 			Display: &armcdn.OperationDisplay{
	// 				Operation: to.Ptr("delete"),
	// 				Provider: to.Ptr("Microsoft.Cdn"),
	// 				Resource: to.Ptr("Profile"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.Cdn/operationresults/profileresults/CheckResourceUsage/action"),
	// 			Display: &armcdn.OperationDisplay{
	// 				Operation: to.Ptr("CheckResourceUsage"),
	// 				Provider: to.Ptr("Microsoft.Cdn"),
	// 				Resource: to.Ptr("Profile"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.Cdn/operationresults/profileresults/GenerateSsoUri/action"),
	// 			Display: &armcdn.OperationDisplay{
	// 				Operation: to.Ptr("GenerateSsoUri"),
	// 				Provider: to.Ptr("Microsoft.Cdn"),
	// 				Resource: to.Ptr("Profile"),
	// 			},
	// 	}},
	// }
}

Output:

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	// Result of the request to list CDN operations. It contains a list of operations and a URL link to get the next set of results.
	OperationsListResult
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type OperationsListResult 

type OperationsListResult struct {
	// URL to get the next set of operation list results if there are any.
	NextLink *string

	// List of CDN operations supported by the CDN resource provider.
	Value []*Operation
}

OperationsListResult - Result of the request to list CDN operations. It contains a list of operations and a URL link to get the next set of results.

func (OperationsListResult) MarshalJSON 

func (o OperationsListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationsListResult.

func (*OperationsListResult) UnmarshalJSON 

func (o *OperationsListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationsListResult.

type Operator 

type Operator string

Operator - Describes operator to be matched 

const (
	OperatorAny                Operator = "Any"
	OperatorBeginsWith         Operator = "BeginsWith"
	OperatorContains           Operator = "Contains"
	OperatorEndsWith           Operator = "EndsWith"
	OperatorEqual              Operator = "Equal"
	OperatorGeoMatch           Operator = "GeoMatch"
	OperatorGreaterThan        Operator = "GreaterThan"
	OperatorGreaterThanOrEqual Operator = "GreaterThanOrEqual"
	OperatorIPMatch            Operator = "IPMatch"
	OperatorLessThan           Operator = "LessThan"
	OperatorLessThanOrEqual    Operator = "LessThanOrEqual"
	OperatorRegEx              Operator = "RegEx"
)

func PossibleOperatorValues 

func PossibleOperatorValues() []Operator

PossibleOperatorValues returns the possible values for the Operator const type.

type OptimizationType 

type OptimizationType string

OptimizationType - Specifies what scenario the customer wants this CDN endpoint to optimize, e.g. Download, Media services. With this information we can apply scenario driven optimization. 

const (
	OptimizationTypeDynamicSiteAcceleration     OptimizationType = "DynamicSiteAcceleration"
	OptimizationTypeGeneralMediaStreaming       OptimizationType = "GeneralMediaStreaming"
	OptimizationTypeGeneralWebDelivery          OptimizationType = "GeneralWebDelivery"
	OptimizationTypeLargeFileDownload           OptimizationType = "LargeFileDownload"
	OptimizationTypeVideoOnDemandMediaStreaming OptimizationType = "VideoOnDemandMediaStreaming"
)

func PossibleOptimizationTypeValues 

func PossibleOptimizationTypeValues() []OptimizationType

PossibleOptimizationTypeValues returns the possible values for the OptimizationType const type.

type Origin 

type Origin struct {
	// The JSON object that contains the properties of the origin.
	Properties *OriginProperties

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Read only system data
	SystemData *SystemData

	// READ-ONLY; Resource type.
	Type *string
}

Origin - CDN origin is the source of the content being delivered via CDN. When the edge nodes represented by an endpoint do not have the requested content cached, they attempt to fetch it from one or more of the configured origins.

func (Origin) MarshalJSON 

func (o Origin) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Origin.

func (*Origin) UnmarshalJSON 

func (o *Origin) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Origin.

type OriginGroup 

type OriginGroup struct {
	// The JSON object that contains the properties of the origin group.
	Properties *OriginGroupProperties

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Read only system data
	SystemData *SystemData

	// READ-ONLY; Resource type.
	Type *string
}

OriginGroup - Origin group comprising of origins is used for load balancing to origins when the content cannot be served from CDN.

func (OriginGroup) MarshalJSON 

func (o OriginGroup) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OriginGroup.

func (*OriginGroup) UnmarshalJSON 

func (o *OriginGroup) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OriginGroup.

type OriginGroupListResult 

type OriginGroupListResult struct {
	// URL to get the next set of origin objects if there are any.
	NextLink *string

	// READ-ONLY; List of CDN origin groups within an endpoint
	Value []*OriginGroup
}

OriginGroupListResult - Result of the request to list origin groups. It contains a list of origin groups objects and a URL link to get the next set of results.

func (OriginGroupListResult) MarshalJSON 

func (o OriginGroupListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OriginGroupListResult.

func (*OriginGroupListResult) UnmarshalJSON 

func (o *OriginGroupListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OriginGroupListResult.

type OriginGroupOverride 

type OriginGroupOverride struct {
	// Protocol this rule will use when forwarding traffic to backends.
	ForwardingProtocol *ForwardingProtocol

	// defines the OriginGroup that would override the DefaultOriginGroup on route.
	OriginGroup *ResourceReference
}

OriginGroupOverride - Defines the parameters for the origin group override configuration.

func (OriginGroupOverride) MarshalJSON 

func (o OriginGroupOverride) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OriginGroupOverride.

func (*OriginGroupOverride) UnmarshalJSON 

func (o *OriginGroupOverride) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OriginGroupOverride.

type OriginGroupOverrideAction 

type OriginGroupOverrideAction struct {
	// REQUIRED; The name of the action for the delivery rule.
	Name *DeliveryRuleAction

	// REQUIRED; Defines the parameters for the action.
	Parameters *OriginGroupOverrideActionParameters
}

OriginGroupOverrideAction - Defines the origin group override action for the delivery rule.

func (*OriginGroupOverrideAction) GetDeliveryRuleActionAutoGenerated 

func (o *OriginGroupOverrideAction) GetDeliveryRuleActionAutoGenerated() *DeliveryRuleActionAutoGenerated

GetDeliveryRuleActionAutoGenerated implements the DeliveryRuleActionAutoGeneratedClassification interface for type OriginGroupOverrideAction.

func (OriginGroupOverrideAction) MarshalJSON 

func (o OriginGroupOverrideAction) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OriginGroupOverrideAction.

func (*OriginGroupOverrideAction) UnmarshalJSON 

func (o *OriginGroupOverrideAction) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OriginGroupOverrideAction.

type OriginGroupOverrideActionParameters 

type OriginGroupOverrideActionParameters struct {
	// REQUIRED; defines the OriginGroup that would override the DefaultOriginGroup.
	OriginGroup *ResourceReference

	// REQUIRED
	TypeName *OriginGroupOverrideActionParametersTypeName
}

OriginGroupOverrideActionParameters - Defines the parameters for the origin group override action.

func (OriginGroupOverrideActionParameters) MarshalJSON 

func (o OriginGroupOverrideActionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OriginGroupOverrideActionParameters.

func (*OriginGroupOverrideActionParameters) UnmarshalJSON 

func (o *OriginGroupOverrideActionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OriginGroupOverrideActionParameters.

type OriginGroupOverrideActionParametersTypeName 

type OriginGroupOverrideActionParametersTypeName string
const (
	OriginGroupOverrideActionParametersTypeNameDeliveryRuleOriginGroupOverrideActionParameters OriginGroupOverrideActionParametersTypeName = "DeliveryRuleOriginGroupOverrideActionParameters"
)

func PossibleOriginGroupOverrideActionParametersTypeNameValues 

func PossibleOriginGroupOverrideActionParametersTypeNameValues() []OriginGroupOverrideActionParametersTypeName

PossibleOriginGroupOverrideActionParametersTypeNameValues returns the possible values for the OriginGroupOverrideActionParametersTypeName const type.

type OriginGroupProperties 

type OriginGroupProperties struct {
	// Health probe settings to the origin that is used to determine the health of the origin.
	HealthProbeSettings *HealthProbeParameters

	// The source of the content being delivered via CDN within given origin group.
	Origins []*ResourceReference

	// The JSON object that contains the properties to determine origin health using real requests/responses. This property is
	// currently not supported.
	ResponseBasedOriginErrorDetectionSettings *ResponseBasedOriginErrorDetectionParameters

	// Time in minutes to shift the traffic to the endpoint gradually when an unhealthy endpoint comes healthy or a new endpoint
	// is added. Default is 10 mins. This property is currently not supported.
	TrafficRestorationTimeToHealedOrNewEndpointsInMinutes *int32

	// READ-ONLY; Provisioning status of the origin group.
	ProvisioningState *OriginGroupProvisioningState

	// READ-ONLY; Resource status of the origin group.
	ResourceState *OriginGroupResourceState
}

OriginGroupProperties - The JSON object that contains the properties of the origin group.

func (OriginGroupProperties) MarshalJSON 

func (o OriginGroupProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OriginGroupProperties.

func (*OriginGroupProperties) UnmarshalJSON 

func (o *OriginGroupProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OriginGroupProperties.

type OriginGroupProvisioningState 

type OriginGroupProvisioningState string

OriginGroupProvisioningState - Provisioning status of the origin group. 

const (
	OriginGroupProvisioningStateCreating  OriginGroupProvisioningState = "Creating"
	OriginGroupProvisioningStateDeleting  OriginGroupProvisioningState = "Deleting"
	OriginGroupProvisioningStateFailed    OriginGroupProvisioningState = "Failed"
	OriginGroupProvisioningStateSucceeded OriginGroupProvisioningState = "Succeeded"
	OriginGroupProvisioningStateUpdating  OriginGroupProvisioningState = "Updating"
)

func PossibleOriginGroupProvisioningStateValues 

func PossibleOriginGroupProvisioningStateValues() []OriginGroupProvisioningState

PossibleOriginGroupProvisioningStateValues returns the possible values for the OriginGroupProvisioningState const type.

type OriginGroupResourceState 

type OriginGroupResourceState string

OriginGroupResourceState - Resource status of the origin group. 

const (
	OriginGroupResourceStateActive   OriginGroupResourceState = "Active"
	OriginGroupResourceStateCreating OriginGroupResourceState = "Creating"
	OriginGroupResourceStateDeleting OriginGroupResourceState = "Deleting"
)

func PossibleOriginGroupResourceStateValues 

func PossibleOriginGroupResourceStateValues() []OriginGroupResourceState

PossibleOriginGroupResourceStateValues returns the possible values for the OriginGroupResourceState const type.

type OriginGroupUpdateParameters 

type OriginGroupUpdateParameters struct {
	// The JSON object that contains the properties of the origin group.
	Properties *OriginGroupUpdatePropertiesParameters
}

OriginGroupUpdateParameters - Origin group properties needed for origin group creation or update.

func (OriginGroupUpdateParameters) MarshalJSON 

func (o OriginGroupUpdateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OriginGroupUpdateParameters.

func (*OriginGroupUpdateParameters) UnmarshalJSON 

func (o *OriginGroupUpdateParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OriginGroupUpdateParameters.

type OriginGroupUpdatePropertiesParameters 

type OriginGroupUpdatePropertiesParameters struct {
	// Health probe settings to the origin that is used to determine the health of the origin.
	HealthProbeSettings *HealthProbeParameters

	// The source of the content being delivered via CDN within given origin group.
	Origins []*ResourceReference

	// The JSON object that contains the properties to determine origin health using real requests/responses. This property is
	// currently not supported.
	ResponseBasedOriginErrorDetectionSettings *ResponseBasedOriginErrorDetectionParameters

	// Time in minutes to shift the traffic to the endpoint gradually when an unhealthy endpoint comes healthy or a new endpoint
	// is added. Default is 10 mins. This property is currently not supported.
	TrafficRestorationTimeToHealedOrNewEndpointsInMinutes *int32
}

OriginGroupUpdatePropertiesParameters - The JSON object that contains the properties of the origin group.

func (OriginGroupUpdatePropertiesParameters) MarshalJSON 

func (o OriginGroupUpdatePropertiesParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OriginGroupUpdatePropertiesParameters.

func (*OriginGroupUpdatePropertiesParameters) UnmarshalJSON 

func (o *OriginGroupUpdatePropertiesParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OriginGroupUpdatePropertiesParameters.

type OriginGroupsClient 

type OriginGroupsClient struct {
	// contains filtered or unexported fields
}

OriginGroupsClient contains the methods for the OriginGroups group. Don't use this type directly, use NewOriginGroupsClient() instead.

func NewOriginGroupsClient 

func NewOriginGroupsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*OriginGroupsClient, error)

NewOriginGroupsClient creates a new instance of OriginGroupsClient with the specified values.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*OriginGroupsClient) BeginCreate 

func (client *OriginGroupsClient) BeginCreate(ctx context.Context, resourceGroupName string, profileName string, endpointName string, originGroupName string, originGroup OriginGroup, options *OriginGroupsClientBeginCreateOptions) (*runtime.Poller[OriginGroupsClientCreateResponse], error)

BeginCreate - Creates a new origin group within the specified endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • originGroupName - Name of the origin group which is unique within the endpoint.
  • originGroup - Origin group properties
  • options - OriginGroupsClientBeginCreateOptions contains the optional parameters for the OriginGroupsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/OriginGroups_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewOriginGroupsClient().BeginCreate(ctx, "RG", "profile1", "endpoint1", "origingroup1", armcdn.OriginGroup{
	Properties: &armcdn.OriginGroupProperties{
		HealthProbeSettings: &armcdn.HealthProbeParameters{
			ProbeIntervalInSeconds: to.Ptr[int32](120),
			ProbePath:              to.Ptr("/health.aspx"),
			ProbeProtocol:          to.Ptr(armcdn.ProbeProtocolHTTP),
			ProbeRequestType:       to.Ptr(armcdn.HealthProbeRequestTypeGET),
		},
		Origins: []*armcdn.ResourceReference{
			{
				ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/origins/origin1"),
			}},
		ResponseBasedOriginErrorDetectionSettings: &armcdn.ResponseBasedOriginErrorDetectionParameters{
			ResponseBasedDetectedErrorTypes:          to.Ptr(armcdn.ResponseBasedDetectedErrorTypesTCPErrorsOnly),
			ResponseBasedFailoverThresholdPercentage: to.Ptr[int32](10),
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.OriginGroup = armcdn.OriginGroup{
// 	Name: to.Ptr("origingroup1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/endpoints/origingroups"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/originGroups/originGroup1"),
// 	Properties: &armcdn.OriginGroupProperties{
// 		HealthProbeSettings: &armcdn.HealthProbeParameters{
// 			ProbeIntervalInSeconds: to.Ptr[int32](120),
// 			ProbePath: to.Ptr("/health.aspx"),
// 			ProbeProtocol: to.Ptr(armcdn.ProbeProtocolHTTP),
// 			ProbeRequestType: to.Ptr(armcdn.HealthProbeRequestTypeGET),
// 		},
// 		Origins: []*armcdn.ResourceReference{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/origins/origin1"),
// 		}},
// 		ResponseBasedOriginErrorDetectionSettings: &armcdn.ResponseBasedOriginErrorDetectionParameters{
// 			ResponseBasedDetectedErrorTypes: to.Ptr(armcdn.ResponseBasedDetectedErrorTypesTCPErrorsOnly),
// 			ResponseBasedFailoverThresholdPercentage: to.Ptr[int32](10),
// 		},
// 		ProvisioningState: to.Ptr(armcdn.OriginGroupProvisioningStateSucceeded),
// 		ResourceState: to.Ptr(armcdn.OriginGroupResourceStateActive),
// 	},
// }

Output:

func (*OriginGroupsClient) BeginDelete 

func (client *OriginGroupsClient) BeginDelete(ctx context.Context, resourceGroupName string, profileName string, endpointName string, originGroupName string, options *OriginGroupsClientBeginDeleteOptions) (*runtime.Poller[OriginGroupsClientDeleteResponse], error)

BeginDelete - Deletes an existing origin group within an endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • originGroupName - Name of the origin group which is unique within the endpoint.
  • options - OriginGroupsClientBeginDeleteOptions contains the optional parameters for the OriginGroupsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/OriginGroups_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewOriginGroupsClient().BeginDelete(ctx, "RG", "profile1", "endpoint1", "originGroup1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*OriginGroupsClient) BeginUpdate 

func (client *OriginGroupsClient) BeginUpdate(ctx context.Context, resourceGroupName string, profileName string, endpointName string, originGroupName string, originGroupUpdateProperties OriginGroupUpdateParameters, options *OriginGroupsClientBeginUpdateOptions) (*runtime.Poller[OriginGroupsClientUpdateResponse], error)

BeginUpdate - Updates an existing origin group within an endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • originGroupName - Name of the origin group which is unique within the endpoint.
  • originGroupUpdateProperties - Origin group properties
  • options - OriginGroupsClientBeginUpdateOptions contains the optional parameters for the OriginGroupsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/OriginGroups_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewOriginGroupsClient().BeginUpdate(ctx, "RG", "profile1", "endpoint1", "originGroup1", armcdn.OriginGroupUpdateParameters{
	Properties: &armcdn.OriginGroupUpdatePropertiesParameters{
		HealthProbeSettings: &armcdn.HealthProbeParameters{
			ProbeIntervalInSeconds: to.Ptr[int32](120),
			ProbePath:              to.Ptr("/health.aspx"),
			ProbeProtocol:          to.Ptr(armcdn.ProbeProtocolHTTP),
			ProbeRequestType:       to.Ptr(armcdn.HealthProbeRequestTypeGET),
		},
		Origins: []*armcdn.ResourceReference{
			{
				ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/origins/origin2"),
			}},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.OriginGroup = armcdn.OriginGroup{
// 	Name: to.Ptr("www-someDomain-net"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/endpoints/origins"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/origins/www-someDomain-net"),
// 	Properties: &armcdn.OriginGroupProperties{
// 		HealthProbeSettings: &armcdn.HealthProbeParameters{
// 			ProbeIntervalInSeconds: to.Ptr[int32](120),
// 			ProbePath: to.Ptr("/health.aspx"),
// 			ProbeProtocol: to.Ptr(armcdn.ProbeProtocolHTTP),
// 			ProbeRequestType: to.Ptr(armcdn.HealthProbeRequestTypeGET),
// 		},
// 		Origins: []*armcdn.ResourceReference{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/origins/origin2"),
// 		}},
// 		ProvisioningState: to.Ptr(armcdn.OriginGroupProvisioningStateSucceeded),
// 		ResourceState: to.Ptr(armcdn.OriginGroupResourceStateActive),
// 	},
// }

Output:

func (*OriginGroupsClient) Get 

func (client *OriginGroupsClient) Get(ctx context.Context, resourceGroupName string, profileName string, endpointName string, originGroupName string, options *OriginGroupsClientGetOptions) (OriginGroupsClientGetResponse, error)

Get - Gets an existing origin group within an endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • originGroupName - Name of the origin group which is unique within the endpoint.
  • options - OriginGroupsClientGetOptions contains the optional parameters for the OriginGroupsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/OriginGroups_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewOriginGroupsClient().Get(ctx, "RG", "profile1", "endpoint1", "originGroup1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.OriginGroup = armcdn.OriginGroup{
// 	Name: to.Ptr("origingroup1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/endpoints/origingroups"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/originGroups/originGroup1"),
// 	Properties: &armcdn.OriginGroupProperties{
// 		HealthProbeSettings: &armcdn.HealthProbeParameters{
// 			ProbeIntervalInSeconds: to.Ptr[int32](120),
// 			ProbePath: to.Ptr("/health.aspx"),
// 			ProbeProtocol: to.Ptr(armcdn.ProbeProtocolHTTP),
// 			ProbeRequestType: to.Ptr(armcdn.HealthProbeRequestTypeGET),
// 		},
// 		Origins: []*armcdn.ResourceReference{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/origins/origin1"),
// 		}},
// 		ResponseBasedOriginErrorDetectionSettings: &armcdn.ResponseBasedOriginErrorDetectionParameters{
// 			HTTPErrorRanges: []*armcdn.HTTPErrorRangeParameters{
// 				{
// 					Begin: to.Ptr[int32](500),
// 					End: to.Ptr[int32](505),
// 			}},
// 			ResponseBasedDetectedErrorTypes: to.Ptr(armcdn.ResponseBasedDetectedErrorTypesTCPAndHTTPErrors),
// 			ResponseBasedFailoverThresholdPercentage: to.Ptr[int32](10),
// 		},
// 		ProvisioningState: to.Ptr(armcdn.OriginGroupProvisioningStateSucceeded),
// 		ResourceState: to.Ptr(armcdn.OriginGroupResourceStateActive),
// 	},
// }

Output:

func (*OriginGroupsClient) NewListByEndpointPager 

func (client *OriginGroupsClient) NewListByEndpointPager(resourceGroupName string, profileName string, endpointName string, options *OriginGroupsClientListByEndpointOptions) *runtime.Pager[OriginGroupsClientListByEndpointResponse]

NewListByEndpointPager - Lists all of the existing origin groups within an endpoint.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • options - OriginGroupsClientListByEndpointOptions contains the optional parameters for the OriginGroupsClient.NewListByEndpointPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/OriginGroups_ListByEndpoint.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewOriginGroupsClient().NewListByEndpointPager("RG", "profile1", "endpoint1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.OriginGroupListResult = armcdn.OriginGroupListResult{
	// 	Value: []*armcdn.OriginGroup{
	// 		{
	// 			Name: to.Ptr("origingroup1"),
	// 			Type: to.Ptr("Microsoft.Cdn/profiles/endpoints/origingroups"),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/originGroups/originGroup1"),
	// 			Properties: &armcdn.OriginGroupProperties{
	// 				HealthProbeSettings: &armcdn.HealthProbeParameters{
	// 					ProbeIntervalInSeconds: to.Ptr[int32](120),
	// 					ProbePath: to.Ptr("/health.aspx"),
	// 					ProbeProtocol: to.Ptr(armcdn.ProbeProtocolHTTP),
	// 					ProbeRequestType: to.Ptr(armcdn.HealthProbeRequestTypeGET),
	// 				},
	// 				Origins: []*armcdn.ResourceReference{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/origins/origin1"),
	// 				}},
	// 				ResponseBasedOriginErrorDetectionSettings: &armcdn.ResponseBasedOriginErrorDetectionParameters{
	// 					ResponseBasedDetectedErrorTypes: to.Ptr(armcdn.ResponseBasedDetectedErrorTypesTCPErrorsOnly),
	// 					ResponseBasedFailoverThresholdPercentage: to.Ptr[int32](10),
	// 				},
	// 				ProvisioningState: to.Ptr(armcdn.OriginGroupProvisioningStateSucceeded),
	// 				ResourceState: to.Ptr(armcdn.OriginGroupResourceStateActive),
	// 			},
	// 	}},
	// }
}

Output:

type OriginGroupsClientBeginCreateOptions 

type OriginGroupsClientBeginCreateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

OriginGroupsClientBeginCreateOptions contains the optional parameters for the OriginGroupsClient.BeginCreate method.

type OriginGroupsClientBeginDeleteOptions 

type OriginGroupsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

OriginGroupsClientBeginDeleteOptions contains the optional parameters for the OriginGroupsClient.BeginDelete method.

type OriginGroupsClientBeginUpdateOptions 

type OriginGroupsClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

OriginGroupsClientBeginUpdateOptions contains the optional parameters for the OriginGroupsClient.BeginUpdate method.

type OriginGroupsClientCreateResponse 

type OriginGroupsClientCreateResponse struct {
	// Origin group comprising of origins is used for load balancing to origins when the content cannot be served from CDN.
	OriginGroup
}

OriginGroupsClientCreateResponse contains the response from method OriginGroupsClient.BeginCreate.

type OriginGroupsClientDeleteResponse 

type OriginGroupsClientDeleteResponse struct {
}

OriginGroupsClientDeleteResponse contains the response from method OriginGroupsClient.BeginDelete.

type OriginGroupsClientGetOptions 

type OriginGroupsClientGetOptions struct {
}

OriginGroupsClientGetOptions contains the optional parameters for the OriginGroupsClient.Get method.

type OriginGroupsClientGetResponse 

type OriginGroupsClientGetResponse struct {
	// Origin group comprising of origins is used for load balancing to origins when the content cannot be served from CDN.
	OriginGroup
}

OriginGroupsClientGetResponse contains the response from method OriginGroupsClient.Get.

type OriginGroupsClientListByEndpointOptions 

type OriginGroupsClientListByEndpointOptions struct {
}

OriginGroupsClientListByEndpointOptions contains the optional parameters for the OriginGroupsClient.NewListByEndpointPager method.

type OriginGroupsClientListByEndpointResponse 

type OriginGroupsClientListByEndpointResponse struct {
	// Result of the request to list origin groups. It contains a list of origin groups objects and a URL link to get the next
	// set of results.
	OriginGroupListResult
}

OriginGroupsClientListByEndpointResponse contains the response from method OriginGroupsClient.NewListByEndpointPager.

type OriginGroupsClientUpdateResponse 

type OriginGroupsClientUpdateResponse struct {
	// Origin group comprising of origins is used for load balancing to origins when the content cannot be served from CDN.
	OriginGroup
}

OriginGroupsClientUpdateResponse contains the response from method OriginGroupsClient.BeginUpdate.

type OriginListResult 

type OriginListResult struct {
	// URL to get the next set of origin objects if there are any.
	NextLink *string

	// READ-ONLY; List of CDN origins within an endpoint
	Value []*Origin
}

OriginListResult - Result of the request to list origins. It contains a list of origin objects and a URL link to get the next set of results.

func (OriginListResult) MarshalJSON 

func (o OriginListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OriginListResult.

func (*OriginListResult) UnmarshalJSON 

func (o *OriginListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OriginListResult.

type OriginProperties 

type OriginProperties struct {
	// Origin is enabled for load balancing or not
	Enabled *bool

	// The value of the HTTP port. Must be between 1 and 65535.
	HTTPPort *int32

	// The value of the HTTPS port. Must be between 1 and 65535.
	HTTPSPort *int32

	// The address of the origin. Domain names, IPv4 addresses, and IPv6 addresses are supported.This should be unique across
	// all origins in an endpoint.
	HostName *string

	// The host header value sent to the origin with each request. If you leave this blank, the request hostname determines this
	// value. Azure CDN origins, such as Web Apps, Blob Storage, and Cloud Services
	// require this host header value to match the origin hostname by default. This overrides the host header defined at Endpoint
	OriginHostHeader *string

	// Priority of origin in given origin group for load balancing. Higher priorities will not be used for load balancing if any
	// lower priority origin is healthy.Must be between 1 and 5
	Priority *int32

	// The Alias of the Private Link resource. Populating this optional field indicates that this origin is 'Private'
	PrivateLinkAlias *string

	// A custom message to be included in the approval request to connect to the Private Link.
	PrivateLinkApprovalMessage *string

	// The location of the Private Link resource. Required only if 'privateLinkResourceId' is populated
	PrivateLinkLocation *string

	// The Resource Id of the Private Link resource. Populating this optional field indicates that this backend is 'Private'
	PrivateLinkResourceID *string

	// Weight of the origin in given origin group for load balancing. Must be between 1 and 1000
	Weight *int32

	// READ-ONLY; The approval status for the connection to the Private Link
	PrivateEndpointStatus *PrivateEndpointStatus

	// READ-ONLY; Provisioning status of the origin.
	ProvisioningState *OriginProvisioningState

	// READ-ONLY; Resource status of the origin.
	ResourceState *OriginResourceState
}

OriginProperties - The JSON object that contains the properties of the origin.

func (OriginProperties) MarshalJSON 

func (o OriginProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OriginProperties.

func (*OriginProperties) UnmarshalJSON 

func (o *OriginProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OriginProperties.

type OriginProvisioningState 

type OriginProvisioningState string

OriginProvisioningState - Provisioning status of the origin. 

const (
	OriginProvisioningStateCreating  OriginProvisioningState = "Creating"
	OriginProvisioningStateDeleting  OriginProvisioningState = "Deleting"
	OriginProvisioningStateFailed    OriginProvisioningState = "Failed"
	OriginProvisioningStateSucceeded OriginProvisioningState = "Succeeded"
	OriginProvisioningStateUpdating  OriginProvisioningState = "Updating"
)

func PossibleOriginProvisioningStateValues 

func PossibleOriginProvisioningStateValues() []OriginProvisioningState

PossibleOriginProvisioningStateValues returns the possible values for the OriginProvisioningState const type.

type OriginResourceState 

type OriginResourceState string

OriginResourceState - Resource status of the origin. 

const (
	OriginResourceStateActive   OriginResourceState = "Active"
	OriginResourceStateCreating OriginResourceState = "Creating"
	OriginResourceStateDeleting OriginResourceState = "Deleting"
)

func PossibleOriginResourceStateValues 

func PossibleOriginResourceStateValues() []OriginResourceState

PossibleOriginResourceStateValues returns the possible values for the OriginResourceState const type.

type OriginUpdateParameters 

type OriginUpdateParameters struct {
	// The JSON object that contains the properties of the origin.
	Properties *OriginUpdatePropertiesParameters
}

OriginUpdateParameters - Origin properties needed for origin update.

func (OriginUpdateParameters) MarshalJSON 

func (o OriginUpdateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OriginUpdateParameters.

func (*OriginUpdateParameters) UnmarshalJSON 

func (o *OriginUpdateParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OriginUpdateParameters.

type OriginUpdatePropertiesParameters 

type OriginUpdatePropertiesParameters struct {
	// Origin is enabled for load balancing or not
	Enabled *bool

	// The value of the HTTP port. Must be between 1 and 65535.
	HTTPPort *int32

	// The value of the HTTPS port. Must be between 1 and 65535.
	HTTPSPort *int32

	// The address of the origin. Domain names, IPv4 addresses, and IPv6 addresses are supported.This should be unique across
	// all origins in an endpoint.
	HostName *string

	// The host header value sent to the origin with each request. If you leave this blank, the request hostname determines this
	// value. Azure CDN origins, such as Web Apps, Blob Storage, and Cloud Services
	// require this host header value to match the origin hostname by default. This overrides the host header defined at Endpoint
	OriginHostHeader *string

	// Priority of origin in given origin group for load balancing. Higher priorities will not be used for load balancing if any
	// lower priority origin is healthy.Must be between 1 and 5
	Priority *int32

	// The Alias of the Private Link resource. Populating this optional field indicates that this origin is 'Private'
	PrivateLinkAlias *string

	// A custom message to be included in the approval request to connect to the Private Link.
	PrivateLinkApprovalMessage *string

	// The location of the Private Link resource. Required only if 'privateLinkResourceId' is populated
	PrivateLinkLocation *string

	// The Resource Id of the Private Link resource. Populating this optional field indicates that this backend is 'Private'
	PrivateLinkResourceID *string

	// Weight of the origin in given origin group for load balancing. Must be between 1 and 1000
	Weight *int32
}

OriginUpdatePropertiesParameters - The JSON object that contains the properties of the origin.

func (OriginUpdatePropertiesParameters) MarshalJSON 

func (o OriginUpdatePropertiesParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OriginUpdatePropertiesParameters.

func (*OriginUpdatePropertiesParameters) UnmarshalJSON 

func (o *OriginUpdatePropertiesParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OriginUpdatePropertiesParameters.

type OriginsClient 

type OriginsClient struct {
	// contains filtered or unexported fields
}

OriginsClient contains the methods for the Origins group. Don't use this type directly, use NewOriginsClient() instead.

func NewOriginsClient 

func NewOriginsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*OriginsClient, error)

NewOriginsClient creates a new instance of OriginsClient with the specified values.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*OriginsClient) BeginCreate 

func (client *OriginsClient) BeginCreate(ctx context.Context, resourceGroupName string, profileName string, endpointName string, originName string, origin Origin, options *OriginsClientBeginCreateOptions) (*runtime.Poller[OriginsClientCreateResponse], error)

BeginCreate - Creates a new origin within the specified endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • originName - Name of the origin that is unique within the endpoint.
  • origin - Origin properties
  • options - OriginsClientBeginCreateOptions contains the optional parameters for the OriginsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Origins_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewOriginsClient().BeginCreate(ctx, "RG", "profile1", "endpoint1", "www-someDomain-net", armcdn.Origin{
	Properties: &armcdn.OriginProperties{
		Enabled:                    to.Ptr(true),
		HostName:                   to.Ptr("www.someDomain.net"),
		HTTPPort:                   to.Ptr[int32](80),
		HTTPSPort:                  to.Ptr[int32](443),
		OriginHostHeader:           to.Ptr("www.someDomain.net"),
		Priority:                   to.Ptr[int32](1),
		PrivateLinkApprovalMessage: to.Ptr("Please approve the connection request for this Private Link"),
		PrivateLinkLocation:        to.Ptr("eastus"),
		PrivateLinkResourceID:      to.Ptr("/subscriptions/subid/resourcegroups/rg1/providers/Microsoft.Network/privateLinkServices/pls1"),
		Weight:                     to.Ptr[int32](50),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Origin = armcdn.Origin{
// 	Name: to.Ptr("www-someDomain-net"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/endpoints/origins"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/origins/www-someDomain-net"),
// 	Properties: &armcdn.OriginProperties{
// 		Enabled: to.Ptr(true),
// 		HostName: to.Ptr("www.someDomain.net"),
// 		HTTPPort: to.Ptr[int32](80),
// 		HTTPSPort: to.Ptr[int32](443),
// 		OriginHostHeader: to.Ptr("www.someDomain.net"),
// 		Priority: to.Ptr[int32](1),
// 		PrivateLinkApprovalMessage: to.Ptr("Please approve the connection request for this Private Link"),
// 		PrivateLinkLocation: to.Ptr("eastus"),
// 		PrivateLinkResourceID: to.Ptr("/subscriptions/subid/resourcegroups/rg1/providers/Microsoft.Network/privateLinkServices/pls1"),
// 		Weight: to.Ptr[int32](50),
// 		PrivateEndpointStatus: to.Ptr(armcdn.PrivateEndpointStatusPending),
// 		ProvisioningState: to.Ptr(armcdn.OriginProvisioningStateSucceeded),
// 		ResourceState: to.Ptr(armcdn.OriginResourceStateActive),
// 	},
// }

Output:

func (*OriginsClient) BeginDelete 

func (client *OriginsClient) BeginDelete(ctx context.Context, resourceGroupName string, profileName string, endpointName string, originName string, options *OriginsClientBeginDeleteOptions) (*runtime.Poller[OriginsClientDeleteResponse], error)

BeginDelete - Deletes an existing origin within an endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • originName - Name of the origin which is unique within the endpoint.
  • options - OriginsClientBeginDeleteOptions contains the optional parameters for the OriginsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Origins_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewOriginsClient().BeginDelete(ctx, "RG", "profile1", "endpoint1", "origin1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*OriginsClient) BeginUpdate 

func (client *OriginsClient) BeginUpdate(ctx context.Context, resourceGroupName string, profileName string, endpointName string, originName string, originUpdateProperties OriginUpdateParameters, options *OriginsClientBeginUpdateOptions) (*runtime.Poller[OriginsClientUpdateResponse], error)

BeginUpdate - Updates an existing origin within an endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • originName - Name of the origin which is unique within the endpoint.
  • originUpdateProperties - Origin properties
  • options - OriginsClientBeginUpdateOptions contains the optional parameters for the OriginsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Origins_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewOriginsClient().BeginUpdate(ctx, "RG", "profile1", "endpoint1", "www-someDomain-net", armcdn.OriginUpdateParameters{
	Properties: &armcdn.OriginUpdatePropertiesParameters{
		Enabled:          to.Ptr(true),
		HTTPPort:         to.Ptr[int32](42),
		HTTPSPort:        to.Ptr[int32](43),
		OriginHostHeader: to.Ptr("www.someDomain2.net"),
		Priority:         to.Ptr[int32](1),
		PrivateLinkAlias: to.Ptr("APPSERVER.d84e61f0-0870-4d24-9746-7438fa0019d1.westus2.azure.privatelinkservice"),
		Weight:           to.Ptr[int32](50),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Origin = armcdn.Origin{
// 	Name: to.Ptr("www-someDomain-net"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/endpoints/origins"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/origins/www-someDomain-net"),
// 	Properties: &armcdn.OriginProperties{
// 		Enabled: to.Ptr(true),
// 		HostName: to.Ptr("www.someDomain.net"),
// 		HTTPPort: to.Ptr[int32](42),
// 		HTTPSPort: to.Ptr[int32](43),
// 		OriginHostHeader: to.Ptr("www.someDomain2.net"),
// 		Priority: to.Ptr[int32](1),
// 		PrivateLinkAlias: to.Ptr("APPSERVER.d84e61f0-0870-4d24-9746-7438fa0019d1.westus2.azure.privatelinkservice"),
// 		PrivateLinkApprovalMessage: to.Ptr("Please approve the connection request for this Private Link"),
// 		Weight: to.Ptr[int32](50),
// 		PrivateEndpointStatus: to.Ptr(armcdn.PrivateEndpointStatusPending),
// 		ProvisioningState: to.Ptr(armcdn.OriginProvisioningStateSucceeded),
// 		ResourceState: to.Ptr(armcdn.OriginResourceStateActive),
// 	},
// }

Output:

func (*OriginsClient) Get 

func (client *OriginsClient) Get(ctx context.Context, resourceGroupName string, profileName string, endpointName string, originName string, options *OriginsClientGetOptions) (OriginsClientGetResponse, error)

Get - Gets an existing origin within an endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • originName - Name of the origin which is unique within the endpoint.
  • options - OriginsClientGetOptions contains the optional parameters for the OriginsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Origins_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewOriginsClient().Get(ctx, "RG", "profile1", "endpoint1", "www-someDomain-net", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Origin = armcdn.Origin{
// 	Name: to.Ptr("www-someDomain-net"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/endpoints/origins"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/origins/www-someDomain-net"),
// 	Properties: &armcdn.OriginProperties{
// 		Enabled: to.Ptr(true),
// 		HostName: to.Ptr("www.someDomain.net"),
// 		OriginHostHeader: to.Ptr("www.someDomain.net"),
// 		Priority: to.Ptr[int32](1),
// 		PrivateLinkAlias: to.Ptr("APPSERVER.d84e61f0-0870-4d24-9746-7438fa0019d1.westus2.azure.privatelinkservice"),
// 		PrivateLinkApprovalMessage: to.Ptr("Please approve the connection request for this Private Link"),
// 		Weight: to.Ptr[int32](50),
// 		PrivateEndpointStatus: to.Ptr(armcdn.PrivateEndpointStatusPending),
// 		ProvisioningState: to.Ptr(armcdn.OriginProvisioningStateSucceeded),
// 		ResourceState: to.Ptr(armcdn.OriginResourceStateActive),
// 	},
// }

Output:

func (*OriginsClient) NewListByEndpointPager 

func (client *OriginsClient) NewListByEndpointPager(resourceGroupName string, profileName string, endpointName string, options *OriginsClientListByEndpointOptions) *runtime.Pager[OriginsClientListByEndpointResponse]

NewListByEndpointPager - Lists all of the existing origins within an endpoint.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • options - OriginsClientListByEndpointOptions contains the optional parameters for the OriginsClient.NewListByEndpointPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Origins_ListByEndpoint.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewOriginsClient().NewListByEndpointPager("RG", "profile1", "endpoint1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.OriginListResult = armcdn.OriginListResult{
	// 	Value: []*armcdn.Origin{
	// 		{
	// 			Name: to.Ptr("www-someDomain-net"),
	// 			Type: to.Ptr("Microsoft.Cdn/profiles/endpoints/origins"),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/endpoints/endpoint1/origins/www-someDomain-net"),
	// 			Properties: &armcdn.OriginProperties{
	// 				Enabled: to.Ptr(true),
	// 				HostName: to.Ptr("www.someDomain.net"),
	// 				OriginHostHeader: to.Ptr("www.someDomain.net"),
	// 				Priority: to.Ptr[int32](1),
	// 				PrivateLinkAlias: to.Ptr("APPSERVER.d84e61f0-0870-4d24-9746-7438fa0019d1.westus2.azure.privatelinkservice"),
	// 				PrivateLinkApprovalMessage: to.Ptr("Please approve the connection request for this Private Link"),
	// 				Weight: to.Ptr[int32](50),
	// 				PrivateEndpointStatus: to.Ptr(armcdn.PrivateEndpointStatusPending),
	// 				ProvisioningState: to.Ptr(armcdn.OriginProvisioningStateSucceeded),
	// 				ResourceState: to.Ptr(armcdn.OriginResourceStateActive),
	// 			},
	// 	}},
	// }
}

Output:

type OriginsClientBeginCreateOptions 

type OriginsClientBeginCreateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

OriginsClientBeginCreateOptions contains the optional parameters for the OriginsClient.BeginCreate method.

type OriginsClientBeginDeleteOptions 

type OriginsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

OriginsClientBeginDeleteOptions contains the optional parameters for the OriginsClient.BeginDelete method.

type OriginsClientBeginUpdateOptions 

type OriginsClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

OriginsClientBeginUpdateOptions contains the optional parameters for the OriginsClient.BeginUpdate method.

type OriginsClientCreateResponse 

type OriginsClientCreateResponse struct {
	// CDN origin is the source of the content being delivered via CDN. When the edge nodes represented by an endpoint do not
	// have the requested content cached, they attempt to fetch it from one or more of the configured origins.
	Origin
}

OriginsClientCreateResponse contains the response from method OriginsClient.BeginCreate.

type OriginsClientDeleteResponse 

type OriginsClientDeleteResponse struct {
}

OriginsClientDeleteResponse contains the response from method OriginsClient.BeginDelete.

type OriginsClientGetOptions 

type OriginsClientGetOptions struct {
}

OriginsClientGetOptions contains the optional parameters for the OriginsClient.Get method.

type OriginsClientGetResponse 

type OriginsClientGetResponse struct {
	// CDN origin is the source of the content being delivered via CDN. When the edge nodes represented by an endpoint do not
	// have the requested content cached, they attempt to fetch it from one or more of the configured origins.
	Origin
}

OriginsClientGetResponse contains the response from method OriginsClient.Get.

type OriginsClientListByEndpointOptions 

type OriginsClientListByEndpointOptions struct {
}

OriginsClientListByEndpointOptions contains the optional parameters for the OriginsClient.NewListByEndpointPager method.

type OriginsClientListByEndpointResponse 

type OriginsClientListByEndpointResponse struct {
	// Result of the request to list origins. It contains a list of origin objects and a URL link to get the next set of results.
	OriginListResult
}

OriginsClientListByEndpointResponse contains the response from method OriginsClient.NewListByEndpointPager.

type OriginsClientUpdateResponse 

type OriginsClientUpdateResponse struct {
	// CDN origin is the source of the content being delivered via CDN. When the edge nodes represented by an endpoint do not
	// have the requested content cached, they attempt to fetch it from one or more of the configured origins.
	Origin
}

OriginsClientUpdateResponse contains the response from method OriginsClient.BeginUpdate.

type ParamIndicator 

type ParamIndicator string

ParamIndicator - Indicates the purpose of the parameter 

const (
	ParamIndicatorExpires   ParamIndicator = "Expires"
	ParamIndicatorKeyID     ParamIndicator = "KeyId"
	ParamIndicatorSignature ParamIndicator = "Signature"
)

func PossibleParamIndicatorValues 

func PossibleParamIndicatorValues() []ParamIndicator

PossibleParamIndicatorValues returns the possible values for the ParamIndicator const type.

type PoliciesClient 

type PoliciesClient struct {
	// contains filtered or unexported fields
}

PoliciesClient contains the methods for the Policies group. Don't use this type directly, use NewPoliciesClient() instead.

func NewPoliciesClient 

func NewPoliciesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PoliciesClient, error)

NewPoliciesClient creates a new instance of PoliciesClient with the specified values.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*PoliciesClient) BeginCreateOrUpdate 

func (client *PoliciesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, policyName string, cdnWebApplicationFirewallPolicy WebApplicationFirewallPolicy, options *PoliciesClientBeginCreateOrUpdateOptions) (*runtime.Poller[PoliciesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create or update policy with specified rule set name within a resource group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • policyName - The name of the CdnWebApplicationFirewallPolicy.
  • cdnWebApplicationFirewallPolicy - Policy to be created.
  • options - PoliciesClientBeginCreateOrUpdateOptions contains the optional parameters for the PoliciesClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/WafPolicyCreateOrUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPoliciesClient().BeginCreateOrUpdate(ctx, "rg1", "MicrosoftCdnWafPolicy", armcdn.WebApplicationFirewallPolicy{
	Location: to.Ptr("WestUs"),
	Properties: &armcdn.WebApplicationFirewallPolicyProperties{
		CustomRules: &armcdn.CustomRuleList{
			Rules: []*armcdn.CustomRule{
				{
					Name:         to.Ptr("CustomRule1"),
					Action:       to.Ptr(armcdn.ActionTypeBlock),
					EnabledState: to.Ptr(armcdn.CustomRuleEnabledStateEnabled),
					MatchConditions: []*armcdn.MatchCondition{
						{
							MatchValue: []*string{
								to.Ptr("CH")},
							MatchVariable:   to.Ptr(armcdn.WafMatchVariableRemoteAddr),
							NegateCondition: to.Ptr(false),
							Operator:        to.Ptr(armcdn.OperatorGeoMatch),
							Transforms:      []*armcdn.TransformType{},
						},
						{
							MatchValue: []*string{
								to.Ptr("windows")},
							MatchVariable:   to.Ptr(armcdn.WafMatchVariableRequestHeader),
							NegateCondition: to.Ptr(false),
							Operator:        to.Ptr(armcdn.OperatorContains),
							Selector:        to.Ptr("UserAgent"),
							Transforms:      []*armcdn.TransformType{},
						},
						{
							MatchValue: []*string{
								to.Ptr("<?php"),
								to.Ptr("?>")},
							MatchVariable:   to.Ptr(armcdn.WafMatchVariableQueryString),
							NegateCondition: to.Ptr(false),
							Operator:        to.Ptr(armcdn.OperatorContains),
							Selector:        to.Ptr("search"),
							Transforms: []*armcdn.TransformType{
								to.Ptr(armcdn.TransformTypeURLDecode),
								to.Ptr(armcdn.TransformTypeLowercase)},
						}},
					Priority: to.Ptr[int32](2),
				}},
		},
		ManagedRules: &armcdn.ManagedRuleSetList{
			ManagedRuleSets: []*armcdn.ManagedRuleSet{
				{
					RuleGroupOverrides: []*armcdn.ManagedRuleGroupOverride{
						{
							RuleGroupName: to.Ptr("Group1"),
							Rules: []*armcdn.ManagedRuleOverride{
								{
									Action:       to.Ptr(armcdn.ActionTypeRedirect),
									EnabledState: to.Ptr(armcdn.ManagedRuleEnabledStateEnabled),
									RuleID:       to.Ptr("GROUP1-0001"),
								},
								{
									EnabledState: to.Ptr(armcdn.ManagedRuleEnabledStateDisabled),
									RuleID:       to.Ptr("GROUP1-0002"),
								}},
						}},
					RuleSetType:    to.Ptr("DefaultRuleSet"),
					RuleSetVersion: to.Ptr("preview-1.0"),
				}},
		},
		PolicySettings: &armcdn.PolicySettings{
			DefaultCustomBlockResponseBody:       to.Ptr("PGh0bWw+CjxoZWFkZXI+PHRpdGxlPkhlbGxvPC90aXRsZT48L2hlYWRlcj4KPGJvZHk+CkhlbGxvIHdvcmxkCjwvYm9keT4KPC9odG1sPg=="),
			DefaultCustomBlockResponseStatusCode: to.Ptr(armcdn.PolicySettingsDefaultCustomBlockResponseStatusCode(200)),
			DefaultRedirectURL:                   to.Ptr("http://www.bing.com"),
		},
		RateLimitRules: &armcdn.RateLimitRuleList{
			Rules: []*armcdn.RateLimitRule{
				{
					Name:         to.Ptr("RateLimitRule1"),
					Action:       to.Ptr(armcdn.ActionTypeBlock),
					EnabledState: to.Ptr(armcdn.CustomRuleEnabledStateEnabled),
					MatchConditions: []*armcdn.MatchCondition{
						{
							MatchValue: []*string{
								to.Ptr("192.168.1.0/24"),
								to.Ptr("10.0.0.0/24")},
							MatchVariable:   to.Ptr(armcdn.WafMatchVariableRemoteAddr),
							NegateCondition: to.Ptr(false),
							Operator:        to.Ptr(armcdn.OperatorIPMatch),
							Transforms:      []*armcdn.TransformType{},
						}},
					Priority:                   to.Ptr[int32](1),
					RateLimitDurationInMinutes: to.Ptr[int32](0),
					RateLimitThreshold:         to.Ptr[int32](1000),
				}},
		},
	},
	SKU: &armcdn.SKU{
		Name: to.Ptr(armcdn.SKUNameStandardMicrosoft),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.WebApplicationFirewallPolicy = armcdn.WebApplicationFirewallPolicy{
// 	Name: to.Ptr("MicrosoftCdnWafPolicy"),
// 	Type: to.Ptr("Microsoft.Cdn/cdnwebapplicationfirewallpolicies"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Cdn/CdnWebApplicationFirewallPolicies/MicrosoftCdnWafPolicy"),
// 	Location: to.Ptr("WestUs"),
// 	Tags: map[string]*string{
// 		"key1": to.Ptr("value1"),
// 		"key2": to.Ptr("value2"),
// 	},
// 	Properties: &armcdn.WebApplicationFirewallPolicyProperties{
// 		CustomRules: &armcdn.CustomRuleList{
// 			Rules: []*armcdn.CustomRule{
// 				{
// 					Name: to.Ptr("CustomRule1"),
// 					Action: to.Ptr(armcdn.ActionTypeBlock),
// 					EnabledState: to.Ptr(armcdn.CustomRuleEnabledStateEnabled),
// 					MatchConditions: []*armcdn.MatchCondition{
// 						{
// 							MatchValue: []*string{
// 								to.Ptr("CH")},
// 								MatchVariable: to.Ptr(armcdn.WafMatchVariableRemoteAddr),
// 								NegateCondition: to.Ptr(false),
// 								Operator: to.Ptr(armcdn.OperatorGeoMatch),
// 								Transforms: []*armcdn.TransformType{
// 								},
// 							},
// 							{
// 								MatchValue: []*string{
// 									to.Ptr("windows")},
// 									MatchVariable: to.Ptr(armcdn.WafMatchVariableRequestHeader),
// 									NegateCondition: to.Ptr(false),
// 									Operator: to.Ptr(armcdn.OperatorContains),
// 									Selector: to.Ptr("UserAgent"),
// 									Transforms: []*armcdn.TransformType{
// 									},
// 								},
// 								{
// 									MatchValue: []*string{
// 										to.Ptr("<?php"),
// 										to.Ptr("?>")},
// 										MatchVariable: to.Ptr(armcdn.WafMatchVariableQueryString),
// 										NegateCondition: to.Ptr(false),
// 										Operator: to.Ptr(armcdn.OperatorContains),
// 										Selector: to.Ptr("search"),
// 										Transforms: []*armcdn.TransformType{
// 											to.Ptr(armcdn.TransformTypeURLDecode),
// 											to.Ptr(armcdn.TransformTypeLowercase)},
// 									}},
// 									Priority: to.Ptr[int32](2),
// 							}},
// 						},
// 						EndpointLinks: []*armcdn.LinkedEndpoint{
// 							{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Cdn/profiles/profile1/endpoints/testEndpoint1"),
// 							},
// 							{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Cdn/profiles/profile1/endpoints/testEndpoint2"),
// 						}},
// 						ManagedRules: &armcdn.ManagedRuleSetList{
// 							ManagedRuleSets: []*armcdn.ManagedRuleSet{
// 								{
// 									RuleGroupOverrides: []*armcdn.ManagedRuleGroupOverride{
// 										{
// 											RuleGroupName: to.Ptr("Group1"),
// 											Rules: []*armcdn.ManagedRuleOverride{
// 												{
// 													Action: to.Ptr(armcdn.ActionTypeRedirect),
// 													EnabledState: to.Ptr(armcdn.ManagedRuleEnabledStateEnabled),
// 													RuleID: to.Ptr("GROUP1-0001"),
// 												},
// 												{
// 													EnabledState: to.Ptr(armcdn.ManagedRuleEnabledStateDisabled),
// 													RuleID: to.Ptr("GROUP1-0002"),
// 											}},
// 									}},
// 									RuleSetType: to.Ptr("DefaultRuleSet"),
// 									RuleSetVersion: to.Ptr("preview-1.0"),
// 							}},
// 						},
// 						PolicySettings: &armcdn.PolicySettings{
// 							DefaultCustomBlockResponseBody: to.Ptr("PGh0bWw+CjxoZWFkZXI+PHRpdGxlPkhlbGxvPC90aXRsZT48L2hlYWRlcj4KPGJvZHk+CkhlbGxvIHdvcmxkCjwvYm9keT4KPC9odG1sPg=="),
// 							DefaultCustomBlockResponseStatusCode: to.Ptr(armcdn.PolicySettingsDefaultCustomBlockResponseStatusCode(200)),
// 							DefaultRedirectURL: to.Ptr("http://www.bing.com"),
// 							EnabledState: to.Ptr(armcdn.PolicyEnabledStateEnabled),
// 							Mode: to.Ptr(armcdn.PolicyModePrevention),
// 						},
// 						ProvisioningState: to.Ptr(armcdn.ProvisioningStateSucceeded),
// 						RateLimitRules: &armcdn.RateLimitRuleList{
// 							Rules: []*armcdn.RateLimitRule{
// 								{
// 									Name: to.Ptr("RateLimitRule1"),
// 									Action: to.Ptr(armcdn.ActionTypeBlock),
// 									EnabledState: to.Ptr(armcdn.CustomRuleEnabledStateEnabled),
// 									MatchConditions: []*armcdn.MatchCondition{
// 										{
// 											MatchValue: []*string{
// 												to.Ptr("192.168.1.0/24"),
// 												to.Ptr("10.0.0.0/24")},
// 												MatchVariable: to.Ptr(armcdn.WafMatchVariableRemoteAddr),
// 												NegateCondition: to.Ptr(false),
// 												Operator: to.Ptr(armcdn.OperatorIPMatch),
// 												Transforms: []*armcdn.TransformType{
// 												},
// 										}},
// 										Priority: to.Ptr[int32](1),
// 										RateLimitDurationInMinutes: to.Ptr[int32](0),
// 										RateLimitThreshold: to.Ptr[int32](1000),
// 								}},
// 							},
// 							ResourceState: to.Ptr(armcdn.PolicyResourceStateEnabled),
// 						},
// 						SKU: &armcdn.SKU{
// 							Name: to.Ptr(armcdn.SKUNameStandardMicrosoft),
// 						},
// 					}

Output:

func (*PoliciesClient) BeginUpdate 

func (client *PoliciesClient) BeginUpdate(ctx context.Context, resourceGroupName string, policyName string, cdnWebApplicationFirewallPolicyPatchParameters WebApplicationFirewallPolicyPatchParameters, options *PoliciesClientBeginUpdateOptions) (*runtime.Poller[PoliciesClientUpdateResponse], error)

BeginUpdate - Update an existing CdnWebApplicationFirewallPolicy with the specified policy name under the specified subscription and resource group If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • policyName - The name of the CdnWebApplicationFirewallPolicy.
  • cdnWebApplicationFirewallPolicyPatchParameters - CdnWebApplicationFirewallPolicy parameters to be patched.
  • options - PoliciesClientBeginUpdateOptions contains the optional parameters for the PoliciesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/WafPatchPolicy.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPoliciesClient().BeginUpdate(ctx, "rg1", "MicrosoftCdnWafPolicy", armcdn.WebApplicationFirewallPolicyPatchParameters{
	Tags: map[string]*string{
		"foo": to.Ptr("bar"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.WebApplicationFirewallPolicy = armcdn.WebApplicationFirewallPolicy{
// 	Name: to.Ptr("MicrosoftCdnWafPolicy"),
// 	Type: to.Ptr("Microsoft.Cdn/cdnwebapplicationfirewallpolicies"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Cdn/CdnWebApplicationFirewallPolicies/MicrosoftCdnWafPolicy"),
// 	Location: to.Ptr("WestUs"),
// 	Tags: map[string]*string{
// 		"foo": to.Ptr("bar"),
// 	},
// 	Properties: &armcdn.WebApplicationFirewallPolicyProperties{
// 		CustomRules: &armcdn.CustomRuleList{
// 			Rules: []*armcdn.CustomRule{
// 				{
// 					Name: to.Ptr("CustomRule1"),
// 					Action: to.Ptr(armcdn.ActionTypeBlock),
// 					EnabledState: to.Ptr(armcdn.CustomRuleEnabledStateEnabled),
// 					MatchConditions: []*armcdn.MatchCondition{
// 						{
// 							MatchValue: []*string{
// 								to.Ptr("CH")},
// 								MatchVariable: to.Ptr(armcdn.WafMatchVariableRemoteAddr),
// 								NegateCondition: to.Ptr(false),
// 								Operator: to.Ptr(armcdn.OperatorGeoMatch),
// 								Transforms: []*armcdn.TransformType{
// 								},
// 							},
// 							{
// 								MatchValue: []*string{
// 									to.Ptr("windows")},
// 									MatchVariable: to.Ptr(armcdn.WafMatchVariableRequestHeader),
// 									NegateCondition: to.Ptr(false),
// 									Operator: to.Ptr(armcdn.OperatorContains),
// 									Selector: to.Ptr("UserAgent"),
// 									Transforms: []*armcdn.TransformType{
// 									},
// 								},
// 								{
// 									MatchValue: []*string{
// 										to.Ptr("<?php"),
// 										to.Ptr("?>")},
// 										MatchVariable: to.Ptr(armcdn.WafMatchVariableQueryString),
// 										NegateCondition: to.Ptr(false),
// 										Operator: to.Ptr(armcdn.OperatorContains),
// 										Selector: to.Ptr("search"),
// 										Transforms: []*armcdn.TransformType{
// 											to.Ptr(armcdn.TransformTypeURLDecode),
// 											to.Ptr(armcdn.TransformTypeLowercase)},
// 									}},
// 									Priority: to.Ptr[int32](2),
// 							}},
// 						},
// 						EndpointLinks: []*armcdn.LinkedEndpoint{
// 							{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Cdn/profiles/profile1/endpoints/testEndpoint1"),
// 							},
// 							{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Cdn/profiles/profile1/endpoints/testEndpoint2"),
// 						}},
// 						ManagedRules: &armcdn.ManagedRuleSetList{
// 							ManagedRuleSets: []*armcdn.ManagedRuleSet{
// 								{
// 									RuleGroupOverrides: []*armcdn.ManagedRuleGroupOverride{
// 										{
// 											RuleGroupName: to.Ptr("Group1"),
// 											Rules: []*armcdn.ManagedRuleOverride{
// 												{
// 													Action: to.Ptr(armcdn.ActionTypeRedirect),
// 													EnabledState: to.Ptr(armcdn.ManagedRuleEnabledStateEnabled),
// 													RuleID: to.Ptr("GROUP1-0001"),
// 												},
// 												{
// 													EnabledState: to.Ptr(armcdn.ManagedRuleEnabledStateDisabled),
// 													RuleID: to.Ptr("GROUP1-0002"),
// 											}},
// 									}},
// 									RuleSetType: to.Ptr("DefaultRuleSet"),
// 									RuleSetVersion: to.Ptr("preview-1.0"),
// 							}},
// 						},
// 						PolicySettings: &armcdn.PolicySettings{
// 							DefaultCustomBlockResponseBody: to.Ptr("PGh0bWw+CjxoZWFkZXI+PHRpdGxlPkhlbGxvPC90aXRsZT48L2hlYWRlcj4KPGJvZHk+CkhlbGxvIHdvcmxkCjwvYm9keT4KPC9odG1sPg=="),
// 							DefaultCustomBlockResponseStatusCode: to.Ptr(armcdn.PolicySettingsDefaultCustomBlockResponseStatusCode(403)),
// 							DefaultRedirectURL: to.Ptr("http://www.bing.com"),
// 							EnabledState: to.Ptr(armcdn.PolicyEnabledStateEnabled),
// 							Mode: to.Ptr(armcdn.PolicyModePrevention),
// 						},
// 						ProvisioningState: to.Ptr(armcdn.ProvisioningStateSucceeded),
// 						RateLimitRules: &armcdn.RateLimitRuleList{
// 							Rules: []*armcdn.RateLimitRule{
// 								{
// 									Name: to.Ptr("RateLimitRule1"),
// 									Action: to.Ptr(armcdn.ActionTypeBlock),
// 									EnabledState: to.Ptr(armcdn.CustomRuleEnabledStateEnabled),
// 									MatchConditions: []*armcdn.MatchCondition{
// 										{
// 											MatchValue: []*string{
// 												to.Ptr("192.168.1.0/24"),
// 												to.Ptr("10.0.0.0/24")},
// 												MatchVariable: to.Ptr(armcdn.WafMatchVariableRemoteAddr),
// 												NegateCondition: to.Ptr(false),
// 												Operator: to.Ptr(armcdn.OperatorIPMatch),
// 												Transforms: []*armcdn.TransformType{
// 												},
// 										}},
// 										Priority: to.Ptr[int32](1),
// 										RateLimitDurationInMinutes: to.Ptr[int32](0),
// 										RateLimitThreshold: to.Ptr[int32](1000),
// 								}},
// 							},
// 							ResourceState: to.Ptr(armcdn.PolicyResourceStateEnabled),
// 						},
// 						SKU: &armcdn.SKU{
// 							Name: to.Ptr(armcdn.SKUNameStandardMicrosoft),
// 						},
// 					}

Output:

func (*PoliciesClient) Delete 

func (client *PoliciesClient) Delete(ctx context.Context, resourceGroupName string, policyName string, options *PoliciesClientDeleteOptions) (PoliciesClientDeleteResponse, error)

Delete - Deletes Policy If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • policyName - The name of the CdnWebApplicationFirewallPolicy.
  • options - PoliciesClientDeleteOptions contains the optional parameters for the PoliciesClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/WafPolicyDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
_, err = clientFactory.NewPoliciesClient().Delete(ctx, "rg1", "Policy1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}

Output:

func (*PoliciesClient) Get 

func (client *PoliciesClient) Get(ctx context.Context, resourceGroupName string, policyName string, options *PoliciesClientGetOptions) (PoliciesClientGetResponse, error)

Get - Retrieve protection policy with specified name within a resource group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • policyName - The name of the CdnWebApplicationFirewallPolicy.
  • options - PoliciesClientGetOptions contains the optional parameters for the PoliciesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/WafPolicyGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPoliciesClient().Get(ctx, "rg1", "MicrosoftCdnWafPolicy", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.WebApplicationFirewallPolicy = armcdn.WebApplicationFirewallPolicy{
// 	Name: to.Ptr("MicrosoftCdnWafPolicy"),
// 	Type: to.Ptr("Microsoft.Cdn/cdnwebapplicationfirewallpolicies"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Cdn/CdnWebApplicationFirewallPolicies/MicrosoftCdnWafPolicy"),
// 	Location: to.Ptr("WestUs"),
// 	Tags: map[string]*string{
// 		"key1": to.Ptr("value1"),
// 		"key2": to.Ptr("value2"),
// 	},
// 	Properties: &armcdn.WebApplicationFirewallPolicyProperties{
// 		CustomRules: &armcdn.CustomRuleList{
// 			Rules: []*armcdn.CustomRule{
// 				{
// 					Name: to.Ptr("CustomRule1"),
// 					Action: to.Ptr(armcdn.ActionTypeBlock),
// 					EnabledState: to.Ptr(armcdn.CustomRuleEnabledStateEnabled),
// 					MatchConditions: []*armcdn.MatchCondition{
// 						{
// 							MatchValue: []*string{
// 								to.Ptr("CH")},
// 								MatchVariable: to.Ptr(armcdn.WafMatchVariableRemoteAddr),
// 								NegateCondition: to.Ptr(false),
// 								Operator: to.Ptr(armcdn.OperatorGeoMatch),
// 								Transforms: []*armcdn.TransformType{
// 								},
// 							},
// 							{
// 								MatchValue: []*string{
// 									to.Ptr("windows")},
// 									MatchVariable: to.Ptr(armcdn.WafMatchVariableRequestHeader),
// 									NegateCondition: to.Ptr(false),
// 									Operator: to.Ptr(armcdn.OperatorContains),
// 									Selector: to.Ptr("UserAgent"),
// 									Transforms: []*armcdn.TransformType{
// 									},
// 								},
// 								{
// 									MatchValue: []*string{
// 										to.Ptr("<?php"),
// 										to.Ptr("?>")},
// 										MatchVariable: to.Ptr(armcdn.WafMatchVariableQueryString),
// 										NegateCondition: to.Ptr(false),
// 										Operator: to.Ptr(armcdn.OperatorContains),
// 										Selector: to.Ptr("search"),
// 										Transforms: []*armcdn.TransformType{
// 											to.Ptr(armcdn.TransformTypeURLDecode),
// 											to.Ptr(armcdn.TransformTypeLowercase)},
// 									}},
// 									Priority: to.Ptr[int32](2),
// 							}},
// 						},
// 						EndpointLinks: []*armcdn.LinkedEndpoint{
// 							{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Cdn/profiles/profile1/endpoints/testEndpoint1"),
// 							},
// 							{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Cdn/profiles/profile1/endpoints/testEndpoint2"),
// 						}},
// 						ManagedRules: &armcdn.ManagedRuleSetList{
// 							ManagedRuleSets: []*armcdn.ManagedRuleSet{
// 								{
// 									RuleGroupOverrides: []*armcdn.ManagedRuleGroupOverride{
// 										{
// 											RuleGroupName: to.Ptr("Group1"),
// 											Rules: []*armcdn.ManagedRuleOverride{
// 												{
// 													Action: to.Ptr(armcdn.ActionTypeRedirect),
// 													EnabledState: to.Ptr(armcdn.ManagedRuleEnabledStateEnabled),
// 													RuleID: to.Ptr("GROUP1-0001"),
// 												},
// 												{
// 													EnabledState: to.Ptr(armcdn.ManagedRuleEnabledStateDisabled),
// 													RuleID: to.Ptr("GROUP1-0002"),
// 											}},
// 									}},
// 									RuleSetType: to.Ptr("DefaultRuleSet"),
// 									RuleSetVersion: to.Ptr("preview-1.0"),
// 							}},
// 						},
// 						PolicySettings: &armcdn.PolicySettings{
// 							DefaultCustomBlockResponseBody: to.Ptr("PGh0bWw+CjxoZWFkZXI+PHRpdGxlPkhlbGxvPC90aXRsZT48L2hlYWRlcj4KPGJvZHk+CkhlbGxvIHdvcmxkCjwvYm9keT4KPC9odG1sPg=="),
// 							DefaultCustomBlockResponseStatusCode: to.Ptr(armcdn.PolicySettingsDefaultCustomBlockResponseStatusCode(429)),
// 							DefaultRedirectURL: to.Ptr("http://www.bing.com"),
// 							EnabledState: to.Ptr(armcdn.PolicyEnabledStateEnabled),
// 							Mode: to.Ptr(armcdn.PolicyModePrevention),
// 						},
// 						ProvisioningState: to.Ptr(armcdn.ProvisioningStateSucceeded),
// 						RateLimitRules: &armcdn.RateLimitRuleList{
// 							Rules: []*armcdn.RateLimitRule{
// 								{
// 									Name: to.Ptr("RateLimitRule1"),
// 									Action: to.Ptr(armcdn.ActionTypeBlock),
// 									EnabledState: to.Ptr(armcdn.CustomRuleEnabledStateEnabled),
// 									MatchConditions: []*armcdn.MatchCondition{
// 										{
// 											MatchValue: []*string{
// 												to.Ptr("192.168.1.0/24"),
// 												to.Ptr("10.0.0.0/24")},
// 												MatchVariable: to.Ptr(armcdn.WafMatchVariableRemoteAddr),
// 												NegateCondition: to.Ptr(false),
// 												Operator: to.Ptr(armcdn.OperatorIPMatch),
// 												Transforms: []*armcdn.TransformType{
// 												},
// 										}},
// 										Priority: to.Ptr[int32](1),
// 										RateLimitDurationInMinutes: to.Ptr[int32](0),
// 										RateLimitThreshold: to.Ptr[int32](1000),
// 								}},
// 							},
// 							ResourceState: to.Ptr(armcdn.PolicyResourceStateEnabled),
// 						},
// 						SKU: &armcdn.SKU{
// 							Name: to.Ptr(armcdn.SKUNameStandardMicrosoft),
// 						},
// 					}

Output:

func (*PoliciesClient) NewListPager 

func (client *PoliciesClient) NewListPager(resourceGroupName string, options *PoliciesClientListOptions) *runtime.Pager[PoliciesClientListResponse]

NewListPager - Lists all of the protection policies within a resource group.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • options - PoliciesClientListOptions contains the optional parameters for the PoliciesClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/WafListPolicies.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewPoliciesClient().NewListPager("rg1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.WebApplicationFirewallPolicyList = armcdn.WebApplicationFirewallPolicyList{
	// 	Value: []*armcdn.WebApplicationFirewallPolicy{
	// 		{
	// 			Name: to.Ptr("MicrosoftCdnWafPolicy"),
	// 			Type: to.Ptr("Microsoft.Cdn/cdnwebapplicationfirewallpolicies"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Cdn/CdnWebApplicationFirewallPolicies/MicrosoftCdnWafPolicy"),
	// 			Location: to.Ptr("WestUs"),
	// 			Tags: map[string]*string{
	// 				"key1": to.Ptr("value1"),
	// 				"key2": to.Ptr("value2"),
	// 			},
	// 			Properties: &armcdn.WebApplicationFirewallPolicyProperties{
	// 				CustomRules: &armcdn.CustomRuleList{
	// 					Rules: []*armcdn.CustomRule{
	// 						{
	// 							Name: to.Ptr("CustomRule1"),
	// 							Action: to.Ptr(armcdn.ActionTypeBlock),
	// 							EnabledState: to.Ptr(armcdn.CustomRuleEnabledStateEnabled),
	// 							MatchConditions: []*armcdn.MatchCondition{
	// 								{
	// 									MatchValue: []*string{
	// 										to.Ptr("CH")},
	// 										MatchVariable: to.Ptr(armcdn.WafMatchVariableRemoteAddr),
	// 										NegateCondition: to.Ptr(false),
	// 										Operator: to.Ptr(armcdn.OperatorGeoMatch),
	// 										Transforms: []*armcdn.TransformType{
	// 										},
	// 									},
	// 									{
	// 										MatchValue: []*string{
	// 											to.Ptr("windows")},
	// 											MatchVariable: to.Ptr(armcdn.WafMatchVariableRequestHeader),
	// 											NegateCondition: to.Ptr(false),
	// 											Operator: to.Ptr(armcdn.OperatorContains),
	// 											Selector: to.Ptr("UserAgent"),
	// 											Transforms: []*armcdn.TransformType{
	// 											},
	// 										},
	// 										{
	// 											MatchValue: []*string{
	// 												to.Ptr("<?php"),
	// 												to.Ptr("?>")},
	// 												MatchVariable: to.Ptr(armcdn.WafMatchVariableQueryString),
	// 												NegateCondition: to.Ptr(false),
	// 												Operator: to.Ptr(armcdn.OperatorContains),
	// 												Selector: to.Ptr("search"),
	// 												Transforms: []*armcdn.TransformType{
	// 													to.Ptr(armcdn.TransformTypeURLDecode),
	// 													to.Ptr(armcdn.TransformTypeLowercase)},
	// 											}},
	// 											Priority: to.Ptr[int32](2),
	// 									}},
	// 								},
	// 								EndpointLinks: []*armcdn.LinkedEndpoint{
	// 									{
	// 										ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Cdn/profiles/profile1/endpoints/testEndpoint1"),
	// 									},
	// 									{
	// 										ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Cdn/profiles/profile1/endpoints/testEndpoint2"),
	// 								}},
	// 								ManagedRules: &armcdn.ManagedRuleSetList{
	// 									ManagedRuleSets: []*armcdn.ManagedRuleSet{
	// 										{
	// 											RuleGroupOverrides: []*armcdn.ManagedRuleGroupOverride{
	// 												{
	// 													RuleGroupName: to.Ptr("Group1"),
	// 													Rules: []*armcdn.ManagedRuleOverride{
	// 														{
	// 															Action: to.Ptr(armcdn.ActionTypeRedirect),
	// 															EnabledState: to.Ptr(armcdn.ManagedRuleEnabledStateEnabled),
	// 															RuleID: to.Ptr("GROUP1-0001"),
	// 														},
	// 														{
	// 															EnabledState: to.Ptr(armcdn.ManagedRuleEnabledStateDisabled),
	// 															RuleID: to.Ptr("GROUP1-0002"),
	// 													}},
	// 											}},
	// 											RuleSetType: to.Ptr("DefaultRuleSet"),
	// 											RuleSetVersion: to.Ptr("preview-1.0"),
	// 									}},
	// 								},
	// 								PolicySettings: &armcdn.PolicySettings{
	// 									DefaultCustomBlockResponseBody: to.Ptr("PGh0bWw+CjxoZWFkZXI+PHRpdGxlPkhlbGxvPC90aXRsZT48L2hlYWRlcj4KPGJvZHk+CkhlbGxvIHdvcmxkCjwvYm9keT4KPC9odG1sPg=="),
	// 									DefaultCustomBlockResponseStatusCode: to.Ptr(armcdn.PolicySettingsDefaultCustomBlockResponseStatusCode(429)),
	// 									DefaultRedirectURL: to.Ptr("http://www.bing.com"),
	// 									EnabledState: to.Ptr(armcdn.PolicyEnabledStateEnabled),
	// 									Mode: to.Ptr(armcdn.PolicyModePrevention),
	// 								},
	// 								ProvisioningState: to.Ptr(armcdn.ProvisioningStateSucceeded),
	// 								RateLimitRules: &armcdn.RateLimitRuleList{
	// 									Rules: []*armcdn.RateLimitRule{
	// 										{
	// 											Name: to.Ptr("RateLimitRule1"),
	// 											Action: to.Ptr(armcdn.ActionTypeBlock),
	// 											EnabledState: to.Ptr(armcdn.CustomRuleEnabledStateEnabled),
	// 											MatchConditions: []*armcdn.MatchCondition{
	// 												{
	// 													MatchValue: []*string{
	// 														to.Ptr("192.168.1.0/24"),
	// 														to.Ptr("10.0.0.0/24")},
	// 														MatchVariable: to.Ptr(armcdn.WafMatchVariableRemoteAddr),
	// 														NegateCondition: to.Ptr(false),
	// 														Operator: to.Ptr(armcdn.OperatorIPMatch),
	// 														Transforms: []*armcdn.TransformType{
	// 														},
	// 												}},
	// 												Priority: to.Ptr[int32](1),
	// 												RateLimitDurationInMinutes: to.Ptr[int32](0),
	// 												RateLimitThreshold: to.Ptr[int32](1000),
	// 										}},
	// 									},
	// 									ResourceState: to.Ptr(armcdn.PolicyResourceStateEnabled),
	// 								},
	// 								SKU: &armcdn.SKU{
	// 									Name: to.Ptr(armcdn.SKUNameStandardMicrosoft),
	// 								},
	// 							},
	// 							{
	// 								Name: to.Ptr("VerizonStandardCdnWafPolicy"),
	// 								Type: to.Ptr("Microsoft.Cdn/cdnwebapplicationfirewallpolicies"),
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Cdn/CdnWebApplicationFirewallPolicies/VerizonStandardCdnWafPolicy"),
	// 								Location: to.Ptr("WestUs"),
	// 								Tags: map[string]*string{
	// 									"key1": to.Ptr("value1"),
	// 									"key2": to.Ptr("value2"),
	// 								},
	// 								Properties: &armcdn.WebApplicationFirewallPolicyProperties{
	// 									CustomRules: &armcdn.CustomRuleList{
	// 										Rules: []*armcdn.CustomRule{
	// 											{
	// 												Name: to.Ptr("CustomRule1"),
	// 												Action: to.Ptr(armcdn.ActionTypeBlock),
	// 												EnabledState: to.Ptr(armcdn.CustomRuleEnabledStateEnabled),
	// 												MatchConditions: []*armcdn.MatchCondition{
	// 													{
	// 														MatchValue: []*string{
	// 															to.Ptr("CH")},
	// 															MatchVariable: to.Ptr(armcdn.WafMatchVariableRemoteAddr),
	// 															NegateCondition: to.Ptr(false),
	// 															Operator: to.Ptr(armcdn.OperatorGeoMatch),
	// 															Transforms: []*armcdn.TransformType{
	// 															},
	// 														},
	// 														{
	// 															MatchValue: []*string{
	// 																to.Ptr("windows")},
	// 																MatchVariable: to.Ptr(armcdn.WafMatchVariableRequestHeader),
	// 																NegateCondition: to.Ptr(false),
	// 																Operator: to.Ptr(armcdn.OperatorContains),
	// 																Selector: to.Ptr("UserAgent"),
	// 															},
	// 															{
	// 																MatchValue: []*string{
	// 																	to.Ptr("<?php"),
	// 																	to.Ptr("?>")},
	// 																	MatchVariable: to.Ptr(armcdn.WafMatchVariableQueryString),
	// 																	NegateCondition: to.Ptr(false),
	// 																	Operator: to.Ptr(armcdn.OperatorContains),
	// 																	Selector: to.Ptr("search"),
	// 																	Transforms: []*armcdn.TransformType{
	// 																		to.Ptr(armcdn.TransformTypeURLDecode),
	// 																		to.Ptr(armcdn.TransformTypeLowercase)},
	// 																}},
	// 																Priority: to.Ptr[int32](2),
	// 														}},
	// 													},
	// 													EndpointLinks: []*armcdn.LinkedEndpoint{
	// 														{
	// 															ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Cdn/profiles/profile1/endpoints/testEndpoint3"),
	// 													}},
	// 													ManagedRules: &armcdn.ManagedRuleSetList{
	// 														ManagedRuleSets: []*armcdn.ManagedRuleSet{
	// 															{
	// 																RuleGroupOverrides: []*armcdn.ManagedRuleGroupOverride{
	// 																	{
	// 																		RuleGroupName: to.Ptr("XSS"),
	// 																		Rules: []*armcdn.ManagedRuleOverride{
	// 																			{
	// 																				Action: to.Ptr(armcdn.ActionTypeRedirect),
	// 																				EnabledState: to.Ptr(armcdn.ManagedRuleEnabledStateEnabled),
	// 																				RuleID: to.Ptr("XSS-0001"),
	// 																			},
	// 																			{
	// 																				EnabledState: to.Ptr(armcdn.ManagedRuleEnabledStateDisabled),
	// 																				RuleID: to.Ptr("XSS-0002"),
	// 																		}},
	// 																}},
	// 																RuleSetType: to.Ptr("ECRS"),
	// 																RuleSetVersion: to.Ptr("2018-11-2"),
	// 														}},
	// 													},
	// 													PolicySettings: &armcdn.PolicySettings{
	// 														DefaultCustomBlockResponseBody: to.Ptr("PGh0bWw+CjxoZWFkZXI+PHRpdGxlPkhlbGxvPC90aXRsZT48L2hlYWRlcj4KPGJvZHk+CkhlbGxvIHdvcmxkCjwvYm9keT4KPC9odG1sPg=="),
	// 														DefaultCustomBlockResponseStatusCode: to.Ptr(armcdn.PolicySettingsDefaultCustomBlockResponseStatusCode(429)),
	// 														DefaultRedirectURL: to.Ptr("http://www.bing.com"),
	// 														EnabledState: to.Ptr(armcdn.PolicyEnabledStateEnabled),
	// 														Mode: to.Ptr(armcdn.PolicyModePrevention),
	// 													},
	// 													ProvisioningState: to.Ptr(armcdn.ProvisioningStateSucceeded),
	// 													RateLimitRules: &armcdn.RateLimitRuleList{
	// 														Rules: []*armcdn.RateLimitRule{
	// 															{
	// 																Name: to.Ptr("RateLimitRule1"),
	// 																Action: to.Ptr(armcdn.ActionTypeBlock),
	// 																EnabledState: to.Ptr(armcdn.CustomRuleEnabledStateEnabled),
	// 																MatchConditions: []*armcdn.MatchCondition{
	// 																	{
	// 																		MatchValue: []*string{
	// 																			to.Ptr("192.168.1.0/24"),
	// 																			to.Ptr("10.0.0.0/24")},
	// 																			MatchVariable: to.Ptr(armcdn.WafMatchVariableRemoteAddr),
	// 																			NegateCondition: to.Ptr(false),
	// 																			Operator: to.Ptr(armcdn.OperatorIPMatch),
	// 																			Transforms: []*armcdn.TransformType{
	// 																			},
	// 																	}},
	// 																	Priority: to.Ptr[int32](1),
	// 																	RateLimitDurationInMinutes: to.Ptr[int32](0),
	// 																	RateLimitThreshold: to.Ptr[int32](1000),
	// 															}},
	// 														},
	// 														ResourceState: to.Ptr(armcdn.PolicyResourceStateEnabled),
	// 													},
	// 													SKU: &armcdn.SKU{
	// 														Name: to.Ptr(armcdn.SKUNameStandardVerizon),
	// 													},
	// 											}},
	// 										}
}

Output:

type PoliciesClientBeginCreateOrUpdateOptions 

type PoliciesClientBeginCreateOrUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

PoliciesClientBeginCreateOrUpdateOptions contains the optional parameters for the PoliciesClient.BeginCreateOrUpdate method.

type PoliciesClientBeginUpdateOptions 

type PoliciesClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

PoliciesClientBeginUpdateOptions contains the optional parameters for the PoliciesClient.BeginUpdate method.

type PoliciesClientCreateOrUpdateResponse 

type PoliciesClientCreateOrUpdateResponse struct {
	// Defines web application firewall policy for Azure CDN.
	WebApplicationFirewallPolicy
}

PoliciesClientCreateOrUpdateResponse contains the response from method PoliciesClient.BeginCreateOrUpdate.

type PoliciesClientDeleteOptions 

type PoliciesClientDeleteOptions struct {
}

PoliciesClientDeleteOptions contains the optional parameters for the PoliciesClient.Delete method.

type PoliciesClientDeleteResponse 

type PoliciesClientDeleteResponse struct {
}

PoliciesClientDeleteResponse contains the response from method PoliciesClient.Delete.

type PoliciesClientGetOptions 

type PoliciesClientGetOptions struct {
}

PoliciesClientGetOptions contains the optional parameters for the PoliciesClient.Get method.

type PoliciesClientGetResponse 

type PoliciesClientGetResponse struct {
	// Defines web application firewall policy for Azure CDN.
	WebApplicationFirewallPolicy
}

PoliciesClientGetResponse contains the response from method PoliciesClient.Get.

type PoliciesClientListOptions 

type PoliciesClientListOptions struct {
}

PoliciesClientListOptions contains the optional parameters for the PoliciesClient.NewListPager method.

type PoliciesClientListResponse 

type PoliciesClientListResponse struct {
	// Defines a list of WebApplicationFirewallPolicies for Azure CDN. It contains a list of WebApplicationFirewallPolicy objects
	// and a URL link to get the next set of results.
	WebApplicationFirewallPolicyList
}

PoliciesClientListResponse contains the response from method PoliciesClient.NewListPager.

type PoliciesClientUpdateResponse 

type PoliciesClientUpdateResponse struct {
	// Defines web application firewall policy for Azure CDN.
	WebApplicationFirewallPolicy
}

PoliciesClientUpdateResponse contains the response from method PoliciesClient.BeginUpdate.

type PolicyEnabledState 

type PolicyEnabledState string

PolicyEnabledState - describes if the policy is in enabled state or disabled state 

const (
	PolicyEnabledStateDisabled PolicyEnabledState = "Disabled"
	PolicyEnabledStateEnabled  PolicyEnabledState = "Enabled"
)

func PossiblePolicyEnabledStateValues 

func PossiblePolicyEnabledStateValues() []PolicyEnabledState

PossiblePolicyEnabledStateValues returns the possible values for the PolicyEnabledState const type.

type PolicyMode 

type PolicyMode string

PolicyMode - Describes if it is in detection mode or prevention mode at policy level. 

const (
	PolicyModeDetection  PolicyMode = "Detection"
	PolicyModePrevention PolicyMode = "Prevention"
)

func PossiblePolicyModeValues 

func PossiblePolicyModeValues() []PolicyMode

PossiblePolicyModeValues returns the possible values for the PolicyMode const type.

type PolicyResourceState 

type PolicyResourceState string

PolicyResourceState - Resource status of the policy. 

const (
	PolicyResourceStateCreating  PolicyResourceState = "Creating"
	PolicyResourceStateDeleting  PolicyResourceState = "Deleting"
	PolicyResourceStateDisabled  PolicyResourceState = "Disabled"
	PolicyResourceStateDisabling PolicyResourceState = "Disabling"
	PolicyResourceStateEnabled   PolicyResourceState = "Enabled"
	PolicyResourceStateEnabling  PolicyResourceState = "Enabling"
)

func PossiblePolicyResourceStateValues 

func PossiblePolicyResourceStateValues() []PolicyResourceState

PossiblePolicyResourceStateValues returns the possible values for the PolicyResourceState const type.

type PolicySettings 

type PolicySettings struct {
	// If the action type is block, customer can override the response body. The body must be specified in base64 encoding.
	DefaultCustomBlockResponseBody *string

	// If the action type is block, this field defines the default customer overridable http response status code.
	DefaultCustomBlockResponseStatusCode *PolicySettingsDefaultCustomBlockResponseStatusCode

	// If action type is redirect, this field represents the default redirect URL for the client.
	DefaultRedirectURL *string

	// describes if the policy is in enabled state or disabled state
	EnabledState *PolicyEnabledState

	// Describes if it is in detection mode or prevention mode at policy level.
	Mode *PolicyMode
}

PolicySettings - Defines contents of a web application firewall global configuration

func (PolicySettings) MarshalJSON 

func (p PolicySettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PolicySettings.

func (*PolicySettings) UnmarshalJSON 

func (p *PolicySettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PolicySettings.

type PolicySettingsDefaultCustomBlockResponseStatusCode 

type PolicySettingsDefaultCustomBlockResponseStatusCode int32

PolicySettingsDefaultCustomBlockResponseStatusCode - If the action type is block, this field defines the default customer overridable http response status code. 

const (
	PolicySettingsDefaultCustomBlockResponseStatusCodeFourHundredFive       PolicySettingsDefaultCustomBlockResponseStatusCode = 405
	PolicySettingsDefaultCustomBlockResponseStatusCodeFourHundredSix        PolicySettingsDefaultCustomBlockResponseStatusCode = 406
	PolicySettingsDefaultCustomBlockResponseStatusCodeFourHundredThree      PolicySettingsDefaultCustomBlockResponseStatusCode = 403
	PolicySettingsDefaultCustomBlockResponseStatusCodeFourHundredTwentyNine PolicySettingsDefaultCustomBlockResponseStatusCode = 429
	PolicySettingsDefaultCustomBlockResponseStatusCodeTwoHundred            PolicySettingsDefaultCustomBlockResponseStatusCode = 200
)

func PossiblePolicySettingsDefaultCustomBlockResponseStatusCodeValues 

func PossiblePolicySettingsDefaultCustomBlockResponseStatusCodeValues() []PolicySettingsDefaultCustomBlockResponseStatusCode

PossiblePolicySettingsDefaultCustomBlockResponseStatusCodeValues returns the possible values for the PolicySettingsDefaultCustomBlockResponseStatusCode const type.

type PostArgsMatchConditionParameters 

type PostArgsMatchConditionParameters struct {
	// REQUIRED; Describes operator to be matched
	Operator *PostArgsOperator

	// REQUIRED
	TypeName *PostArgsMatchConditionParametersTypeName

	// The match value for the condition of the delivery rule
	MatchValues []*string

	// Describes if this is negate condition or not
	NegateCondition *bool

	// Name of PostArg to be matched
	Selector *string

	// List of transforms
	Transforms []*Transform
}

PostArgsMatchConditionParameters - Defines the parameters for PostArgs match conditions

func (PostArgsMatchConditionParameters) MarshalJSON 

func (p PostArgsMatchConditionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PostArgsMatchConditionParameters.

func (*PostArgsMatchConditionParameters) UnmarshalJSON 

func (p *PostArgsMatchConditionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PostArgsMatchConditionParameters.

type PostArgsMatchConditionParametersTypeName 

type PostArgsMatchConditionParametersTypeName string
const (
	PostArgsMatchConditionParametersTypeNameDeliveryRulePostArgsConditionParameters PostArgsMatchConditionParametersTypeName = "DeliveryRulePostArgsConditionParameters"
)

func PossiblePostArgsMatchConditionParametersTypeNameValues 

func PossiblePostArgsMatchConditionParametersTypeNameValues() []PostArgsMatchConditionParametersTypeName

PossiblePostArgsMatchConditionParametersTypeNameValues returns the possible values for the PostArgsMatchConditionParametersTypeName const type.

type PostArgsOperator 

type PostArgsOperator string

PostArgsOperator - Describes operator to be matched 

const (
	PostArgsOperatorAny                PostArgsOperator = "Any"
	PostArgsOperatorBeginsWith         PostArgsOperator = "BeginsWith"
	PostArgsOperatorContains           PostArgsOperator = "Contains"
	PostArgsOperatorEndsWith           PostArgsOperator = "EndsWith"
	PostArgsOperatorEqual              PostArgsOperator = "Equal"
	PostArgsOperatorGreaterThan        PostArgsOperator = "GreaterThan"
	PostArgsOperatorGreaterThanOrEqual PostArgsOperator = "GreaterThanOrEqual"
	PostArgsOperatorLessThan           PostArgsOperator = "LessThan"
	PostArgsOperatorLessThanOrEqual    PostArgsOperator = "LessThanOrEqual"
	PostArgsOperatorRegEx              PostArgsOperator = "RegEx"
)

func PossiblePostArgsOperatorValues 

func PossiblePostArgsOperatorValues() []PostArgsOperator

PossiblePostArgsOperatorValues returns the possible values for the PostArgsOperator const type.

type PrivateEndpointStatus 

type PrivateEndpointStatus string

PrivateEndpointStatus - The approval status for the connection to the Private Link 

const (
	PrivateEndpointStatusApproved     PrivateEndpointStatus = "Approved"
	PrivateEndpointStatusDisconnected PrivateEndpointStatus = "Disconnected"
	PrivateEndpointStatusPending      PrivateEndpointStatus = "Pending"
	PrivateEndpointStatusRejected     PrivateEndpointStatus = "Rejected"
	PrivateEndpointStatusTimeout      PrivateEndpointStatus = "Timeout"
)

func PossiblePrivateEndpointStatusValues 

func PossiblePrivateEndpointStatusValues() []PrivateEndpointStatus

PossiblePrivateEndpointStatusValues returns the possible values for the PrivateEndpointStatus const type.

type ProbeProtocol 

type ProbeProtocol string

ProbeProtocol - Protocol to use for health probe. 

const (
	ProbeProtocolHTTP   ProbeProtocol = "Http"
	ProbeProtocolHTTPS  ProbeProtocol = "Https"
	ProbeProtocolNotSet ProbeProtocol = "NotSet"
)

func PossibleProbeProtocolValues 

func PossibleProbeProtocolValues() []ProbeProtocol

PossibleProbeProtocolValues returns the possible values for the ProbeProtocol const type.

type Profile 

type Profile struct {
	// REQUIRED; Resource location.
	Location *string

	// REQUIRED; The pricing tier (defines Azure Front Door Standard or Premium or a CDN provider, feature list and rate) of the
	// profile.
	SKU *SKU

	// Managed service identity (system assigned and/or user assigned identities).
	Identity *ManagedServiceIdentity

	// The JSON object that contains the properties required to create a profile.
	Properties *ProfileProperties

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Kind of the profile. Used by portal to differentiate traditional CDN profile and new AFD profile.
	Kind *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Read only system data
	SystemData *SystemData

	// READ-ONLY; Resource type.
	Type *string
}

Profile - A profile is a logical grouping of endpoints that share the same settings.

func (Profile) MarshalJSON 

func (p Profile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Profile.

func (*Profile) UnmarshalJSON 

func (p *Profile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Profile.

type ProfileChangeSKUWafMapping 

type ProfileChangeSKUWafMapping struct {
	// REQUIRED; The new waf resource for the security policy to use.
	ChangeToWafPolicy *ResourceReference

	// REQUIRED; The security policy name.
	SecurityPolicyName *string
}

ProfileChangeSKUWafMapping - Parameters required for profile upgrade.

func (ProfileChangeSKUWafMapping) MarshalJSON 

func (p ProfileChangeSKUWafMapping) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ProfileChangeSKUWafMapping.

func (*ProfileChangeSKUWafMapping) UnmarshalJSON 

func (p *ProfileChangeSKUWafMapping) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ProfileChangeSKUWafMapping.

type ProfileListResult 

type ProfileListResult struct {
	// URL to get the next set of profile objects if there are any.
	NextLink *string

	// READ-ONLY; List of CDN profiles within a resource group.
	Value []*Profile
}

ProfileListResult - Result of the request to list profiles. It contains a list of profile objects and a URL link to get the next set of results.

func (ProfileListResult) MarshalJSON 

func (p ProfileListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ProfileListResult.

func (*ProfileListResult) UnmarshalJSON 

func (p *ProfileListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ProfileListResult.

type ProfileLogScrubbing added in v2.2.0 

type ProfileLogScrubbing struct {
	// List of log scrubbing rules applied to the Azure Front Door profile logs.
	ScrubbingRules []*ProfileScrubbingRules

	// State of the log scrubbing config. Default value is Enabled.
	State *ProfileScrubbingState
}

ProfileLogScrubbing - Defines rules that scrub sensitive fields in the Azure Front Door profile logs.

func (ProfileLogScrubbing) MarshalJSON added in v2.2.0 

func (p ProfileLogScrubbing) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ProfileLogScrubbing.

func (*ProfileLogScrubbing) UnmarshalJSON added in v2.2.0 

func (p *ProfileLogScrubbing) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ProfileLogScrubbing.

type ProfileProperties 

type ProfileProperties struct {
	// Defines rules that scrub sensitive fields in the Azure Front Door profile logs.
	LogScrubbing *ProfileLogScrubbing

	// Send and receive timeout on forwarding request to the origin. When timeout is reached, the request fails and returns.
	OriginResponseTimeoutSeconds *int32

	// READ-ONLY; Key-Value pair representing additional properties for profiles.
	ExtendedProperties map[string]*string

	// READ-ONLY; The Id of the frontdoor.
	FrontDoorID *string

	// READ-ONLY; Provisioning status of the profile.
	ProvisioningState *ProfileProvisioningState

	// READ-ONLY; Resource status of the profile.
	ResourceState *ProfileResourceState
}

ProfileProperties - The JSON object that contains the properties required to create a profile.

func (ProfileProperties) MarshalJSON 

func (p ProfileProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ProfileProperties.

func (*ProfileProperties) UnmarshalJSON 

func (p *ProfileProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ProfileProperties.

type ProfilePropertiesUpdateParameters 

type ProfilePropertiesUpdateParameters struct {
	// Defines rules to scrub sensitive fields in logs
	LogScrubbing *ProfileLogScrubbing

	// Send and receive timeout on forwarding request to the origin. When timeout is reached, the request fails and returns.
	OriginResponseTimeoutSeconds *int32
}

ProfilePropertiesUpdateParameters - The JSON object containing profile update parameters.

func (ProfilePropertiesUpdateParameters) MarshalJSON 

func (p ProfilePropertiesUpdateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ProfilePropertiesUpdateParameters.

func (*ProfilePropertiesUpdateParameters) UnmarshalJSON 

func (p *ProfilePropertiesUpdateParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ProfilePropertiesUpdateParameters.

type ProfileProvisioningState 

type ProfileProvisioningState string

ProfileProvisioningState - Provisioning status of the profile. 

const (
	ProfileProvisioningStateCreating  ProfileProvisioningState = "Creating"
	ProfileProvisioningStateDeleting  ProfileProvisioningState = "Deleting"
	ProfileProvisioningStateFailed    ProfileProvisioningState = "Failed"
	ProfileProvisioningStateSucceeded ProfileProvisioningState = "Succeeded"
	ProfileProvisioningStateUpdating  ProfileProvisioningState = "Updating"
)

func PossibleProfileProvisioningStateValues 

func PossibleProfileProvisioningStateValues() []ProfileProvisioningState

PossibleProfileProvisioningStateValues returns the possible values for the ProfileProvisioningState const type.

type ProfileResourceState 

type ProfileResourceState string

ProfileResourceState - Resource status of the profile. 

const (
	ProfileResourceStateAbortingMigration      ProfileResourceState = "AbortingMigration"
	ProfileResourceStateActive                 ProfileResourceState = "Active"
	ProfileResourceStateCommittingMigration    ProfileResourceState = "CommittingMigration"
	ProfileResourceStateCreating               ProfileResourceState = "Creating"
	ProfileResourceStateDeleting               ProfileResourceState = "Deleting"
	ProfileResourceStateDisabled               ProfileResourceState = "Disabled"
	ProfileResourceStateMigrated               ProfileResourceState = "Migrated"
	ProfileResourceStateMigrating              ProfileResourceState = "Migrating"
	ProfileResourceStatePendingMigrationCommit ProfileResourceState = "PendingMigrationCommit"
)

func PossibleProfileResourceStateValues 

func PossibleProfileResourceStateValues() []ProfileResourceState

PossibleProfileResourceStateValues returns the possible values for the ProfileResourceState const type.

type ProfileScrubbingRules added in v2.2.0 

type ProfileScrubbingRules struct {
	// REQUIRED; The variable to be scrubbed from the logs.
	MatchVariable *ScrubbingRuleEntryMatchVariable

	// REQUIRED; When matchVariable is a collection, operate on the selector to specify which elements in the collection this
	// rule applies to.
	SelectorMatchOperator *ScrubbingRuleEntryMatchOperator

	// When matchVariable is a collection, operator used to specify which elements in the collection this rule applies to.
	Selector *string

	// Defines the state of a log scrubbing rule. Default value is enabled.
	State *ScrubbingRuleEntryState
}

ProfileScrubbingRules - Defines the contents of the log scrubbing rules.

func (ProfileScrubbingRules) MarshalJSON added in v2.2.0 

func (p ProfileScrubbingRules) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ProfileScrubbingRules.

func (*ProfileScrubbingRules) UnmarshalJSON added in v2.2.0 

func (p *ProfileScrubbingRules) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ProfileScrubbingRules.

type ProfileScrubbingState added in v2.2.0 

type ProfileScrubbingState string

ProfileScrubbingState - State of the log scrubbing config. Default value is Enabled. 

const (
	ProfileScrubbingStateDisabled ProfileScrubbingState = "Disabled"
	ProfileScrubbingStateEnabled  ProfileScrubbingState = "Enabled"
)

func PossibleProfileScrubbingStateValues added in v2.2.0 

func PossibleProfileScrubbingStateValues() []ProfileScrubbingState

PossibleProfileScrubbingStateValues returns the possible values for the ProfileScrubbingState const type.

type ProfileUpdateParameters 

type ProfileUpdateParameters struct {
	// Managed service identity (system assigned and/or user assigned identities).
	Identity *ManagedServiceIdentity

	// The JSON object containing profile update parameters.
	Properties *ProfilePropertiesUpdateParameters

	// Profile tags
	Tags map[string]*string
}

ProfileUpdateParameters - Properties required to update a profile.

func (ProfileUpdateParameters) MarshalJSON 

func (p ProfileUpdateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ProfileUpdateParameters.

func (*ProfileUpdateParameters) UnmarshalJSON 

func (p *ProfileUpdateParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ProfileUpdateParameters.

type ProfileUpgradeParameters 

type ProfileUpgradeParameters struct {
	// REQUIRED; Web Application Firewall (WAF) and security policy mapping for the profile upgrade
	WafMappingList []*ProfileChangeSKUWafMapping
}

ProfileUpgradeParameters - Parameters required for profile upgrade.

func (ProfileUpgradeParameters) MarshalJSON 

func (p ProfileUpgradeParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ProfileUpgradeParameters.

func (*ProfileUpgradeParameters) UnmarshalJSON 

func (p *ProfileUpgradeParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ProfileUpgradeParameters.

type ProfilesClient 

type ProfilesClient struct {
	// contains filtered or unexported fields
}

ProfilesClient contains the methods for the Profiles group. Don't use this type directly, use NewProfilesClient() instead.

func NewProfilesClient 

func NewProfilesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ProfilesClient, error)

NewProfilesClient creates a new instance of ProfilesClient with the specified values.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ProfilesClient) BeginCanMigrate 

func (client *ProfilesClient) BeginCanMigrate(ctx context.Context, resourceGroupName string, canMigrateParameters CanMigrateParameters, options *ProfilesClientBeginCanMigrateOptions) (*runtime.Poller[ProfilesClientCanMigrateResponse], error)

BeginCanMigrate - Checks if CDN profile can be migrated to Azure Frontdoor(Standard/Premium) profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • canMigrateParameters - Properties needed to check if cdn profile or classic frontdoor can be migrated.
  • options - ProfilesClientBeginCanMigrateOptions contains the optional parameters for the ProfilesClient.BeginCanMigrate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Profiles_CanMigrate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewProfilesClient().BeginCanMigrate(ctx, "RG", armcdn.CanMigrateParameters{
	ClassicResourceReference: &armcdn.ResourceReference{
		ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Network/frontdoors/frontdoorname"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.CanMigrateResult = armcdn.CanMigrateResult{
// 	Type: to.Ptr("Microsoft.Cdn/canmigrate"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/yaoshitest/providers/Microsoft.Cdn/operationresults/operationid/profileresults/DummyProfile/canmigrateresults/DummyProfile"),
// 	Properties: &armcdn.CanMigrateProperties{
// 		CanMigrate: to.Ptr(true),
// 		DefaultSKU: to.Ptr(armcdn.CanMigrateDefaultSKUStandardAzureFrontDoor),
// 	},
// }

Output:

func (*ProfilesClient) BeginCreate 

func (client *ProfilesClient) BeginCreate(ctx context.Context, resourceGroupName string, profileName string, profile Profile, options *ProfilesClientBeginCreateOptions) (*runtime.Poller[ProfilesClientCreateResponse], error)

BeginCreate - Creates a new Azure Front Door Standard or Azure Front Door Premium or CDN profile with a profile name under the specified subscription and resource group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium or CDN profile which is unique within the resource group.
  • profile - Profile properties needed to create a new profile.
  • options - ProfilesClientBeginCreateOptions contains the optional parameters for the ProfilesClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Profiles_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewProfilesClient().BeginCreate(ctx, "RG", "profile1", armcdn.Profile{
	Location: to.Ptr("global"),
	SKU: &armcdn.SKU{
		Name: to.Ptr(armcdn.SKUNamePremiumAzureFrontDoor),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Profile = armcdn.Profile{
// 	Name: to.Ptr("profile1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1"),
// 	Location: to.Ptr("global"),
// 	Tags: map[string]*string{
// 	},
// 	Kind: to.Ptr("frontdoor"),
// 	Properties: &armcdn.ProfileProperties{
// 		FrontDoorID: to.Ptr("3b4682da-b3e2-47a1-96ca-08ab3cb7294e"),
// 		OriginResponseTimeoutSeconds: to.Ptr[int32](30),
// 		ProvisioningState: to.Ptr(armcdn.ProfileProvisioningStateSucceeded),
// 		ResourceState: to.Ptr(armcdn.ProfileResourceStateActive),
// 	},
// 	SKU: &armcdn.SKU{
// 		Name: to.Ptr(armcdn.SKUNamePremiumAzureFrontDoor),
// 	},
// }

Output:

func (*ProfilesClient) BeginDelete 

func (client *ProfilesClient) BeginDelete(ctx context.Context, resourceGroupName string, profileName string, options *ProfilesClientBeginDeleteOptions) (*runtime.Poller[ProfilesClientDeleteResponse], error)

BeginDelete - Deletes an existing Azure Front Door Standard or Azure Front Door Premium or CDN profile with the specified parameters. Deleting a profile will result in the deletion of all of the sub-resources including endpoints, origins and custom domains. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium or CDN profile which is unique within the resource group.
  • options - ProfilesClientBeginDeleteOptions contains the optional parameters for the ProfilesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Profiles_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewProfilesClient().BeginDelete(ctx, "RG", "profile1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*ProfilesClient) BeginMigrate 

func (client *ProfilesClient) BeginMigrate(ctx context.Context, resourceGroupName string, migrationParameters MigrationParameters, options *ProfilesClientBeginMigrateOptions) (*runtime.Poller[ProfilesClientMigrateResponse], error)

BeginMigrate - Migrate the CDN profile to Azure Frontdoor(Standard/Premium) profile. The change need to be committed after this. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • migrationParameters - Properties needed to migrate the profile.
  • options - ProfilesClientBeginMigrateOptions contains the optional parameters for the ProfilesClient.BeginMigrate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Profiles_Migrate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewProfilesClient().BeginMigrate(ctx, "RG", armcdn.MigrationParameters{
	ClassicResourceReference: &armcdn.ResourceReference{
		ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Network/frontdoors/frontdoorname"),
	},
	ProfileName: to.Ptr("profile1"),
	SKU: &armcdn.SKU{
		Name: to.Ptr(armcdn.SKUNameStandardAzureFrontDoor),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.MigrateResult = armcdn.MigrateResult{
// 	Type: to.Ptr("Microsoft.Cdn/migrate"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/operationresults/operationid/profileresults/profile1/migrateresults/profile1"),
// 	Properties: &armcdn.MigrateResultProperties{
// 		MigratedProfileResourceID: &armcdn.ResourceReference{
// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1"),
// 		},
// 	},
// }

Output:

func (*ProfilesClient) BeginMigrationCommit 

func (client *ProfilesClient) BeginMigrationCommit(ctx context.Context, resourceGroupName string, profileName string, options *ProfilesClientBeginMigrationCommitOptions) (*runtime.Poller[ProfilesClientMigrationCommitResponse], error)

BeginMigrationCommit - Commit the migrated Azure Frontdoor(Standard/Premium) profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • options - ProfilesClientBeginMigrationCommitOptions contains the optional parameters for the ProfilesClient.BeginMigrationCommit method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Profiles_MigrationCommit.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewProfilesClient().BeginMigrationCommit(ctx, "RG", "profile1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*ProfilesClient) BeginUpdate 

func (client *ProfilesClient) BeginUpdate(ctx context.Context, resourceGroupName string, profileName string, profileUpdateParameters ProfileUpdateParameters, options *ProfilesClientBeginUpdateOptions) (*runtime.Poller[ProfilesClientUpdateResponse], error)

BeginUpdate - Updates an existing Azure Front Door Standard or Azure Front Door Premium or CDN profile with the specified profile name under the specified subscription and resource group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium or CDN profile which is unique within the resource group.
  • profileUpdateParameters - Profile properties needed to update an existing profile.
  • options - ProfilesClientBeginUpdateOptions contains the optional parameters for the ProfilesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Profiles_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewProfilesClient().BeginUpdate(ctx, "RG", "profile1", armcdn.ProfileUpdateParameters{
	Tags: map[string]*string{
		"additionalProperties": to.Ptr("Tag1"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Profile = armcdn.Profile{
// 	Name: to.Ptr("profile1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1"),
// 	Location: to.Ptr("global"),
// 	Tags: map[string]*string{
// 		"additionalProperties": to.Ptr("Tag1"),
// 	},
// 	Kind: to.Ptr("frontdoor"),
// 	Properties: &armcdn.ProfileProperties{
// 		FrontDoorID: to.Ptr("3b4682da-b3e2-47a1-96ca-08ab3cb7294e"),
// 		LogScrubbing: &armcdn.ProfileLogScrubbing{
// 			ScrubbingRules: []*armcdn.ProfileScrubbingRules{
// 			},
// 			State: to.Ptr(armcdn.ProfileScrubbingStateEnabled),
// 		},
// 		OriginResponseTimeoutSeconds: to.Ptr[int32](30),
// 		ProvisioningState: to.Ptr(armcdn.ProfileProvisioningStateSucceeded),
// 		ResourceState: to.Ptr(armcdn.ProfileResourceStateActive),
// 	},
// 	SKU: &armcdn.SKU{
// 		Name: to.Ptr(armcdn.SKUNamePremiumAzureFrontDoor),
// 	},
// }

Output:

func (*ProfilesClient) GenerateSsoURI 

func (client *ProfilesClient) GenerateSsoURI(ctx context.Context, resourceGroupName string, profileName string, options *ProfilesClientGenerateSsoURIOptions) (ProfilesClientGenerateSsoURIResponse, error)

GenerateSsoURI - Generates a dynamic SSO URI used to sign in to the CDN supplemental portal. Supplemental portal is used to configure advanced feature capabilities that are not yet available in the Azure portal, such as core reports in a standard profile; rules engine, advanced HTTP reports, and real-time stats and alerts in a premium profile. The SSO URI changes approximately every 10 minutes. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the CDN profile which is unique within the resource group.
  • options - ProfilesClientGenerateSsoURIOptions contains the optional parameters for the ProfilesClient.GenerateSsoURI method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Profiles_GenerateSsoUri.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewProfilesClient().GenerateSsoURI(ctx, "RG", "profile1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.SsoURI = armcdn.SsoURI{
// 	SsoURIValue: to.Ptr("https://someuri.com"),
// }

Output:

func (*ProfilesClient) Get 

func (client *ProfilesClient) Get(ctx context.Context, resourceGroupName string, profileName string, options *ProfilesClientGetOptions) (ProfilesClientGetResponse, error)

Get - Gets an Azure Front Door Standard or Azure Front Door Premium or CDN profile with the specified profile name under the specified subscription and resource group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium or CDN profile which is unique within the resource group.
  • options - ProfilesClientGetOptions contains the optional parameters for the ProfilesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Profiles_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewProfilesClient().Get(ctx, "RG", "profile1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Profile = armcdn.Profile{
// 	Name: to.Ptr("profile1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1"),
// 	Location: to.Ptr("global"),
// 	Tags: map[string]*string{
// 	},
// 	Kind: to.Ptr("frontdoor"),
// 	Properties: &armcdn.ProfileProperties{
// 		FrontDoorID: to.Ptr("3b4682da-b3e2-47a1-96ca-08ab3cb7294e"),
// 		LogScrubbing: &armcdn.ProfileLogScrubbing{
// 			ScrubbingRules: []*armcdn.ProfileScrubbingRules{
// 			},
// 			State: to.Ptr(armcdn.ProfileScrubbingStateEnabled),
// 		},
// 		OriginResponseTimeoutSeconds: to.Ptr[int32](30),
// 		ProvisioningState: to.Ptr(armcdn.ProfileProvisioningStateSucceeded),
// 		ResourceState: to.Ptr(armcdn.ProfileResourceStateActive),
// 	},
// 	SKU: &armcdn.SKU{
// 		Name: to.Ptr(armcdn.SKUNamePremiumAzureFrontDoor),
// 	},
// }

Output:

func (*ProfilesClient) ListSupportedOptimizationTypes 

func (client *ProfilesClient) ListSupportedOptimizationTypes(ctx context.Context, resourceGroupName string, profileName string, options *ProfilesClientListSupportedOptimizationTypesOptions) (ProfilesClientListSupportedOptimizationTypesResponse, error)

ListSupportedOptimizationTypes - Gets the supported optimization types for the current profile. A user can create an endpoint with an optimization type from the listed values. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium or CDN profile which is unique within the resource group.
  • options - ProfilesClientListSupportedOptimizationTypesOptions contains the optional parameters for the ProfilesClient.ListSupportedOptimizationTypes method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Profiles_ListSupportedOptimizationTypes.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewProfilesClient().ListSupportedOptimizationTypes(ctx, "RG", "profile1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.SupportedOptimizationTypesListResult = armcdn.SupportedOptimizationTypesListResult{
// 	SupportedOptimizationTypes: []*armcdn.OptimizationType{
// 		to.Ptr(armcdn.OptimizationTypeGeneralWebDelivery),
// 		to.Ptr(armcdn.OptimizationTypeDynamicSiteAcceleration)},
// 	}

Output:

func (*ProfilesClient) NewListByResourceGroupPager 

func (client *ProfilesClient) NewListByResourceGroupPager(resourceGroupName string, options *ProfilesClientListByResourceGroupOptions) *runtime.Pager[ProfilesClientListByResourceGroupResponse]

NewListByResourceGroupPager - Lists all of the Azure Front Door Standard, Azure Front Door Premium, and CDN profiles within a resource group.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • options - ProfilesClientListByResourceGroupOptions contains the optional parameters for the ProfilesClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Profiles_ListByResourceGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewProfilesClient().NewListByResourceGroupPager("RG", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.ProfileListResult = armcdn.ProfileListResult{
	// 	Value: []*armcdn.Profile{
	// 		{
	// 			Name: to.Ptr("profile1"),
	// 			Type: to.Ptr("Microsoft.Cdn/profiles"),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1"),
	// 			Location: to.Ptr("global"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Kind: to.Ptr("frontdoor"),
	// 			Properties: &armcdn.ProfileProperties{
	// 				FrontDoorID: to.Ptr("3b4682da-b3e2-47a1-96ca-08ab3cb7294e"),
	// 				LogScrubbing: &armcdn.ProfileLogScrubbing{
	// 					ScrubbingRules: []*armcdn.ProfileScrubbingRules{
	// 					},
	// 					State: to.Ptr(armcdn.ProfileScrubbingStateEnabled),
	// 				},
	// 				OriginResponseTimeoutSeconds: to.Ptr[int32](30),
	// 				ProvisioningState: to.Ptr(armcdn.ProfileProvisioningStateSucceeded),
	// 				ResourceState: to.Ptr(armcdn.ProfileResourceStateActive),
	// 			},
	// 			SKU: &armcdn.SKU{
	// 				Name: to.Ptr(armcdn.SKUNamePremiumAzureFrontDoor),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("profile2"),
	// 			Type: to.Ptr("Microsoft.Cdn/profiles"),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile2"),
	// 			Location: to.Ptr("global"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Kind: to.Ptr("frontdoor"),
	// 			Properties: &armcdn.ProfileProperties{
	// 				FrontDoorID: to.Ptr("3b4682da-b3e2-47a1-96ca-08ab3cb7294e"),
	// 				LogScrubbing: &armcdn.ProfileLogScrubbing{
	// 					ScrubbingRules: []*armcdn.ProfileScrubbingRules{
	// 					},
	// 					State: to.Ptr(armcdn.ProfileScrubbingStateEnabled),
	// 				},
	// 				OriginResponseTimeoutSeconds: to.Ptr[int32](30),
	// 				ProvisioningState: to.Ptr(armcdn.ProfileProvisioningStateSucceeded),
	// 				ResourceState: to.Ptr(armcdn.ProfileResourceStateActive),
	// 			},
	// 			SKU: &armcdn.SKU{
	// 				Name: to.Ptr(armcdn.SKUNamePremiumAzureFrontDoor),
	// 			},
	// 	}},
	// }
}

Output:

func (*ProfilesClient) NewListPager 

func (client *ProfilesClient) NewListPager(options *ProfilesClientListOptions) *runtime.Pager[ProfilesClientListResponse]

NewListPager - Lists all of the Azure Front Door Standard, Azure Front Door Premium, and CDN profiles within an Azure subscription.

Generated from API version 2024-02-01

  • options - ProfilesClientListOptions contains the optional parameters for the ProfilesClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Profiles_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewProfilesClient().NewListPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.ProfileListResult = armcdn.ProfileListResult{
	// 	Value: []*armcdn.Profile{
	// 		{
	// 			Name: to.Ptr("profile1"),
	// 			Type: to.Ptr("Microsoft.Cdn/profiles"),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG1/providers/Microsoft.Cdn/profiles/profile1"),
	// 			Location: to.Ptr("global"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Kind: to.Ptr("frontdoor"),
	// 			Properties: &armcdn.ProfileProperties{
	// 				FrontDoorID: to.Ptr("3b4682da-b3e2-47a1-96ca-08ab3cb7294e"),
	// 				LogScrubbing: &armcdn.ProfileLogScrubbing{
	// 					ScrubbingRules: []*armcdn.ProfileScrubbingRules{
	// 					},
	// 					State: to.Ptr(armcdn.ProfileScrubbingStateEnabled),
	// 				},
	// 				OriginResponseTimeoutSeconds: to.Ptr[int32](30),
	// 				ProvisioningState: to.Ptr(armcdn.ProfileProvisioningStateSucceeded),
	// 				ResourceState: to.Ptr(armcdn.ProfileResourceStateActive),
	// 			},
	// 			SKU: &armcdn.SKU{
	// 				Name: to.Ptr(armcdn.SKUNamePremiumAzureFrontDoor),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("profile2"),
	// 			Type: to.Ptr("Microsoft.Cdn/profiles"),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG1/providers/Microsoft.Cdn/profiles/profile2"),
	// 			Location: to.Ptr("global"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Kind: to.Ptr("frontdoor"),
	// 			Properties: &armcdn.ProfileProperties{
	// 				FrontDoorID: to.Ptr("3b4682da-b3e2-47a1-96ca-08ab3cb7294e"),
	// 				LogScrubbing: &armcdn.ProfileLogScrubbing{
	// 					ScrubbingRules: []*armcdn.ProfileScrubbingRules{
	// 					},
	// 					State: to.Ptr(armcdn.ProfileScrubbingStateEnabled),
	// 				},
	// 				OriginResponseTimeoutSeconds: to.Ptr[int32](30),
	// 				ProvisioningState: to.Ptr(armcdn.ProfileProvisioningStateSucceeded),
	// 				ResourceState: to.Ptr(armcdn.ProfileResourceStateActive),
	// 			},
	// 			SKU: &armcdn.SKU{
	// 				Name: to.Ptr(armcdn.SKUNamePremiumAzureFrontDoor),
	// 			},
	// 	}},
	// }
}

Output:

func (*ProfilesClient) NewListResourceUsagePager 

func (client *ProfilesClient) NewListResourceUsagePager(resourceGroupName string, profileName string, options *ProfilesClientListResourceUsageOptions) *runtime.Pager[ProfilesClientListResourceUsageResponse]

NewListResourceUsagePager - Checks the quota and actual usage of endpoints under the given Azure Front Door Standard or Azure Front Door Premium or CDN profile.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium or CDN profile which is unique within the resource group.
  • options - ProfilesClientListResourceUsageOptions contains the optional parameters for the ProfilesClient.NewListResourceUsagePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Profiles_ListResourceUsage.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewProfilesClient().NewListResourceUsagePager("RG", "profile1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.ResourceUsageListResult = armcdn.ResourceUsageListResult{
	// 	Value: []*armcdn.ResourceUsage{
	// 		{
	// 			CurrentValue: to.Ptr[int32](0),
	// 			Limit: to.Ptr[int32](25),
	// 			ResourceType: to.Ptr("endpoint"),
	// 			Unit: to.Ptr(armcdn.ResourceUsageUnitCount),
	// 	}},
	// }
}

Output:

type ProfilesClientBeginCanMigrateOptions 

type ProfilesClientBeginCanMigrateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ProfilesClientBeginCanMigrateOptions contains the optional parameters for the ProfilesClient.BeginCanMigrate method.

type ProfilesClientBeginCreateOptions 

type ProfilesClientBeginCreateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ProfilesClientBeginCreateOptions contains the optional parameters for the ProfilesClient.BeginCreate method.

type ProfilesClientBeginDeleteOptions 

type ProfilesClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ProfilesClientBeginDeleteOptions contains the optional parameters for the ProfilesClient.BeginDelete method.

type ProfilesClientBeginMigrateOptions 

type ProfilesClientBeginMigrateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ProfilesClientBeginMigrateOptions contains the optional parameters for the ProfilesClient.BeginMigrate method.

type ProfilesClientBeginMigrationCommitOptions 

type ProfilesClientBeginMigrationCommitOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ProfilesClientBeginMigrationCommitOptions contains the optional parameters for the ProfilesClient.BeginMigrationCommit method.

type ProfilesClientBeginUpdateOptions 

type ProfilesClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ProfilesClientBeginUpdateOptions contains the optional parameters for the ProfilesClient.BeginUpdate method.

type ProfilesClientCanMigrateResponse 

type ProfilesClientCanMigrateResponse struct {
	// Result for canMigrate operation.
	CanMigrateResult
}

ProfilesClientCanMigrateResponse contains the response from method ProfilesClient.BeginCanMigrate.

type ProfilesClientCreateResponse 

type ProfilesClientCreateResponse struct {
	// A profile is a logical grouping of endpoints that share the same settings.
	Profile
}

ProfilesClientCreateResponse contains the response from method ProfilesClient.BeginCreate.

type ProfilesClientDeleteResponse 

type ProfilesClientDeleteResponse struct {
}

ProfilesClientDeleteResponse contains the response from method ProfilesClient.BeginDelete.

type ProfilesClientGenerateSsoURIOptions 

type ProfilesClientGenerateSsoURIOptions struct {
}

ProfilesClientGenerateSsoURIOptions contains the optional parameters for the ProfilesClient.GenerateSsoURI method.

type ProfilesClientGenerateSsoURIResponse 

type ProfilesClientGenerateSsoURIResponse struct {
	// The URI required to login to the supplemental portal from the Azure portal.
	SsoURI
}

ProfilesClientGenerateSsoURIResponse contains the response from method ProfilesClient.GenerateSsoURI.

type ProfilesClientGetOptions 

type ProfilesClientGetOptions struct {
}

ProfilesClientGetOptions contains the optional parameters for the ProfilesClient.Get method.

type ProfilesClientGetResponse 

type ProfilesClientGetResponse struct {
	// A profile is a logical grouping of endpoints that share the same settings.
	Profile
}

ProfilesClientGetResponse contains the response from method ProfilesClient.Get.

type ProfilesClientListByResourceGroupOptions 

type ProfilesClientListByResourceGroupOptions struct {
}

ProfilesClientListByResourceGroupOptions contains the optional parameters for the ProfilesClient.NewListByResourceGroupPager method.

type ProfilesClientListByResourceGroupResponse 

type ProfilesClientListByResourceGroupResponse struct {
	// Result of the request to list profiles. It contains a list of profile objects and a URL link to get the next set of results.
	ProfileListResult
}

ProfilesClientListByResourceGroupResponse contains the response from method ProfilesClient.NewListByResourceGroupPager.

type ProfilesClientListOptions 

type ProfilesClientListOptions struct {
}

ProfilesClientListOptions contains the optional parameters for the ProfilesClient.NewListPager method.

type ProfilesClientListResourceUsageOptions 

type ProfilesClientListResourceUsageOptions struct {
}

ProfilesClientListResourceUsageOptions contains the optional parameters for the ProfilesClient.NewListResourceUsagePager method.

type ProfilesClientListResourceUsageResponse 

type ProfilesClientListResourceUsageResponse struct {
	// Output of check resource usage API.
	ResourceUsageListResult
}

ProfilesClientListResourceUsageResponse contains the response from method ProfilesClient.NewListResourceUsagePager.

type ProfilesClientListResponse 

type ProfilesClientListResponse struct {
	// Result of the request to list profiles. It contains a list of profile objects and a URL link to get the next set of results.
	ProfileListResult
}

ProfilesClientListResponse contains the response from method ProfilesClient.NewListPager.

type ProfilesClientListSupportedOptimizationTypesOptions 

type ProfilesClientListSupportedOptimizationTypesOptions struct {
}

ProfilesClientListSupportedOptimizationTypesOptions contains the optional parameters for the ProfilesClient.ListSupportedOptimizationTypes method.

type ProfilesClientListSupportedOptimizationTypesResponse 

type ProfilesClientListSupportedOptimizationTypesResponse struct {
	// The result of the GetSupportedOptimizationTypes API
	SupportedOptimizationTypesListResult
}

ProfilesClientListSupportedOptimizationTypesResponse contains the response from method ProfilesClient.ListSupportedOptimizationTypes.

type ProfilesClientMigrateResponse 

type ProfilesClientMigrateResponse struct {
	// Result for migrate operation.
	MigrateResult
}

ProfilesClientMigrateResponse contains the response from method ProfilesClient.BeginMigrate.

type ProfilesClientMigrationCommitResponse 

type ProfilesClientMigrationCommitResponse struct {
}

ProfilesClientMigrationCommitResponse contains the response from method ProfilesClient.BeginMigrationCommit.

type ProfilesClientUpdateResponse 

type ProfilesClientUpdateResponse struct {
	// A profile is a logical grouping of endpoints that share the same settings.
	Profile
}

ProfilesClientUpdateResponse contains the response from method ProfilesClient.BeginUpdate.

type ProtocolType 

type ProtocolType string

ProtocolType - Defines the TLS extension protocol that is used for secure delivery. 

const (
	ProtocolTypeIPBased              ProtocolType = "IPBased"
	ProtocolTypeServerNameIndication ProtocolType = "ServerNameIndication"
)

func PossibleProtocolTypeValues 

func PossibleProtocolTypeValues() []ProtocolType

PossibleProtocolTypeValues returns the possible values for the ProtocolType const type.

type ProvisioningState 

type ProvisioningState string

ProvisioningState - Provisioning state of the WebApplicationFirewallPolicy. 

const (
	ProvisioningStateCreating  ProvisioningState = "Creating"
	ProvisioningStateFailed    ProvisioningState = "Failed"
	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
)

func PossibleProvisioningStateValues 

func PossibleProvisioningStateValues() []ProvisioningState

PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.

type PurgeParameters 

type PurgeParameters struct {
	// REQUIRED; The path to the content to be purged. Can describe a file path or a wild card directory.
	ContentPaths []*string
}

PurgeParameters - Parameters required for content purge.

func (PurgeParameters) MarshalJSON 

func (p PurgeParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PurgeParameters.

func (*PurgeParameters) UnmarshalJSON 

func (p *PurgeParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PurgeParameters.

type QueryStringBehavior 

type QueryStringBehavior string

QueryStringBehavior - Caching behavior for the requests 

const (
	QueryStringBehaviorExclude    QueryStringBehavior = "Exclude"
	QueryStringBehaviorExcludeAll QueryStringBehavior = "ExcludeAll"
	QueryStringBehaviorInclude    QueryStringBehavior = "Include"
	QueryStringBehaviorIncludeAll QueryStringBehavior = "IncludeAll"
)

func PossibleQueryStringBehaviorValues 

func PossibleQueryStringBehaviorValues() []QueryStringBehavior

PossibleQueryStringBehaviorValues returns the possible values for the QueryStringBehavior const type.

type QueryStringCachingBehavior 

type QueryStringCachingBehavior string

QueryStringCachingBehavior - Defines how CDN caches requests that include query strings. You can ignore any query strings when caching, bypass caching to prevent requests that contain query strings from being cached, or cache every request with a unique URL. 

const (
	QueryStringCachingBehaviorBypassCaching     QueryStringCachingBehavior = "BypassCaching"
	QueryStringCachingBehaviorIgnoreQueryString QueryStringCachingBehavior = "IgnoreQueryString"
	QueryStringCachingBehaviorNotSet            QueryStringCachingBehavior = "NotSet"
	QueryStringCachingBehaviorUseQueryString    QueryStringCachingBehavior = "UseQueryString"
)

func PossibleQueryStringCachingBehaviorValues 

func PossibleQueryStringCachingBehaviorValues() []QueryStringCachingBehavior

PossibleQueryStringCachingBehaviorValues returns the possible values for the QueryStringCachingBehavior const type.

type QueryStringMatchConditionParameters 

type QueryStringMatchConditionParameters struct {
	// REQUIRED; Describes operator to be matched
	Operator *QueryStringOperator

	// REQUIRED
	TypeName *QueryStringMatchConditionParametersTypeName

	// The match value for the condition of the delivery rule
	MatchValues []*string

	// Describes if this is negate condition or not
	NegateCondition *bool

	// List of transforms
	Transforms []*Transform
}

QueryStringMatchConditionParameters - Defines the parameters for QueryString match conditions

func (QueryStringMatchConditionParameters) MarshalJSON 

func (q QueryStringMatchConditionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type QueryStringMatchConditionParameters.

func (*QueryStringMatchConditionParameters) UnmarshalJSON 

func (q *QueryStringMatchConditionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type QueryStringMatchConditionParameters.

type QueryStringMatchConditionParametersTypeName 

type QueryStringMatchConditionParametersTypeName string
const (
	QueryStringMatchConditionParametersTypeNameDeliveryRuleQueryStringConditionParameters QueryStringMatchConditionParametersTypeName = "DeliveryRuleQueryStringConditionParameters"
)

func PossibleQueryStringMatchConditionParametersTypeNameValues 

func PossibleQueryStringMatchConditionParametersTypeNameValues() []QueryStringMatchConditionParametersTypeName

PossibleQueryStringMatchConditionParametersTypeNameValues returns the possible values for the QueryStringMatchConditionParametersTypeName const type.

type QueryStringOperator 

type QueryStringOperator string

QueryStringOperator - Describes operator to be matched 

const (
	QueryStringOperatorAny                QueryStringOperator = "Any"
	QueryStringOperatorBeginsWith         QueryStringOperator = "BeginsWith"
	QueryStringOperatorContains           QueryStringOperator = "Contains"
	QueryStringOperatorEndsWith           QueryStringOperator = "EndsWith"
	QueryStringOperatorEqual              QueryStringOperator = "Equal"
	QueryStringOperatorGreaterThan        QueryStringOperator = "GreaterThan"
	QueryStringOperatorGreaterThanOrEqual QueryStringOperator = "GreaterThanOrEqual"
	QueryStringOperatorLessThan           QueryStringOperator = "LessThan"
	QueryStringOperatorLessThanOrEqual    QueryStringOperator = "LessThanOrEqual"
	QueryStringOperatorRegEx              QueryStringOperator = "RegEx"
)

func PossibleQueryStringOperatorValues 

func PossibleQueryStringOperatorValues() []QueryStringOperator

PossibleQueryStringOperatorValues returns the possible values for the QueryStringOperator const type.

type RankingsResponse 

type RankingsResponse struct {
	DateTimeBegin *time.Time
	DateTimeEnd   *time.Time
	Tables        []*RankingsResponseTablesItem
}

RankingsResponse - Rankings Response

func (RankingsResponse) MarshalJSON 

func (r RankingsResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RankingsResponse.

func (*RankingsResponse) UnmarshalJSON 

func (r *RankingsResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RankingsResponse.

type RankingsResponseTablesItem 

type RankingsResponseTablesItem struct {
	Data    []*RankingsResponseTablesPropertiesItemsItem
	Ranking *string
}

func (RankingsResponseTablesItem) MarshalJSON 

func (r RankingsResponseTablesItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RankingsResponseTablesItem.

func (*RankingsResponseTablesItem) UnmarshalJSON 

func (r *RankingsResponseTablesItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RankingsResponseTablesItem.

type RankingsResponseTablesPropertiesItemsItem 

type RankingsResponseTablesPropertiesItemsItem struct {
	Metrics []*RankingsResponseTablesPropertiesItemsMetricsItem
	Name    *string
}

func (RankingsResponseTablesPropertiesItemsItem) MarshalJSON 

func (r RankingsResponseTablesPropertiesItemsItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RankingsResponseTablesPropertiesItemsItem.

func (*RankingsResponseTablesPropertiesItemsItem) UnmarshalJSON 

func (r *RankingsResponseTablesPropertiesItemsItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RankingsResponseTablesPropertiesItemsItem.

type RankingsResponseTablesPropertiesItemsMetricsItem 

type RankingsResponseTablesPropertiesItemsMetricsItem struct {
	Metric     *string
	Percentage *float32
	Value      *int64
}

func (RankingsResponseTablesPropertiesItemsMetricsItem) MarshalJSON 

func (r RankingsResponseTablesPropertiesItemsMetricsItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RankingsResponseTablesPropertiesItemsMetricsItem.

func (*RankingsResponseTablesPropertiesItemsMetricsItem) UnmarshalJSON 

func (r *RankingsResponseTablesPropertiesItemsMetricsItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RankingsResponseTablesPropertiesItemsMetricsItem.

type RateLimitRule 

type RateLimitRule struct {
	// REQUIRED; Describes what action to be applied when rule matches
	Action *ActionType

	// REQUIRED; List of match conditions.
	MatchConditions []*MatchCondition

	// REQUIRED; Defines the name of the custom rule
	Name *string

	// REQUIRED; Defines in what order this rule be evaluated in the overall list of custom rules
	Priority *int32

	// REQUIRED; Defines rate limit duration. Default is 1 minute.
	RateLimitDurationInMinutes *int32

	// REQUIRED; Defines rate limit threshold.
	RateLimitThreshold *int32

	// Describes if the custom rule is in enabled or disabled state. Defaults to Enabled if not specified.
	EnabledState *CustomRuleEnabledState
}

RateLimitRule - Defines a rate limiting rule that can be included in a waf policy

func (RateLimitRule) MarshalJSON 

func (r RateLimitRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RateLimitRule.

func (*RateLimitRule) UnmarshalJSON 

func (r *RateLimitRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RateLimitRule.

type RateLimitRuleList 

type RateLimitRuleList struct {
	// List of rules
	Rules []*RateLimitRule
}

RateLimitRuleList - Defines contents of rate limit rules

func (RateLimitRuleList) MarshalJSON 

func (r RateLimitRuleList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RateLimitRuleList.

func (*RateLimitRuleList) UnmarshalJSON 

func (r *RateLimitRuleList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RateLimitRuleList.

type RedirectType 

type RedirectType string

RedirectType - The redirect type the rule will use when redirecting traffic. 

const (
	RedirectTypeFound             RedirectType = "Found"
	RedirectTypeMoved             RedirectType = "Moved"
	RedirectTypePermanentRedirect RedirectType = "PermanentRedirect"
	RedirectTypeTemporaryRedirect RedirectType = "TemporaryRedirect"
)

func PossibleRedirectTypeValues 

func PossibleRedirectTypeValues() []RedirectType

PossibleRedirectTypeValues returns the possible values for the RedirectType const type.

type RemoteAddressMatchConditionParameters 

type RemoteAddressMatchConditionParameters struct {
	// REQUIRED; Describes operator to be matched
	Operator *RemoteAddressOperator

	// REQUIRED
	TypeName *RemoteAddressMatchConditionParametersTypeName

	// Match values to match against. The operator will apply to each value in here with OR semantics. If any of them match the
	// variable with the given operator this match condition is considered a match.
	MatchValues []*string

	// Describes if this is negate condition or not
	NegateCondition *bool

	// List of transforms
	Transforms []*Transform
}

RemoteAddressMatchConditionParameters - Defines the parameters for RemoteAddress match conditions

func (RemoteAddressMatchConditionParameters) MarshalJSON 

func (r RemoteAddressMatchConditionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RemoteAddressMatchConditionParameters.

func (*RemoteAddressMatchConditionParameters) UnmarshalJSON 

func (r *RemoteAddressMatchConditionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RemoteAddressMatchConditionParameters.

type RemoteAddressMatchConditionParametersTypeName 

type RemoteAddressMatchConditionParametersTypeName string
const (
	RemoteAddressMatchConditionParametersTypeNameDeliveryRuleRemoteAddressConditionParameters RemoteAddressMatchConditionParametersTypeName = "DeliveryRuleRemoteAddressConditionParameters"
)

func PossibleRemoteAddressMatchConditionParametersTypeNameValues 

func PossibleRemoteAddressMatchConditionParametersTypeNameValues() []RemoteAddressMatchConditionParametersTypeName

PossibleRemoteAddressMatchConditionParametersTypeNameValues returns the possible values for the RemoteAddressMatchConditionParametersTypeName const type.

type RemoteAddressOperator 

type RemoteAddressOperator string

RemoteAddressOperator - Describes operator to be matched 

const (
	RemoteAddressOperatorAny      RemoteAddressOperator = "Any"
	RemoteAddressOperatorGeoMatch RemoteAddressOperator = "GeoMatch"
	RemoteAddressOperatorIPMatch  RemoteAddressOperator = "IPMatch"
)

func PossibleRemoteAddressOperatorValues 

func PossibleRemoteAddressOperatorValues() []RemoteAddressOperator

PossibleRemoteAddressOperatorValues returns the possible values for the RemoteAddressOperator const type.

type RequestBodyMatchConditionParameters 

type RequestBodyMatchConditionParameters struct {
	// REQUIRED; Describes operator to be matched
	Operator *RequestBodyOperator

	// REQUIRED
	TypeName *RequestBodyMatchConditionParametersTypeName

	// The match value for the condition of the delivery rule
	MatchValues []*string

	// Describes if this is negate condition or not
	NegateCondition *bool

	// List of transforms
	Transforms []*Transform
}

RequestBodyMatchConditionParameters - Defines the parameters for RequestBody match conditions

func (RequestBodyMatchConditionParameters) MarshalJSON 

func (r RequestBodyMatchConditionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RequestBodyMatchConditionParameters.

func (*RequestBodyMatchConditionParameters) UnmarshalJSON 

func (r *RequestBodyMatchConditionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RequestBodyMatchConditionParameters.

type RequestBodyMatchConditionParametersTypeName 

type RequestBodyMatchConditionParametersTypeName string
const (
	RequestBodyMatchConditionParametersTypeNameDeliveryRuleRequestBodyConditionParameters RequestBodyMatchConditionParametersTypeName = "DeliveryRuleRequestBodyConditionParameters"
)

func PossibleRequestBodyMatchConditionParametersTypeNameValues 

func PossibleRequestBodyMatchConditionParametersTypeNameValues() []RequestBodyMatchConditionParametersTypeName

PossibleRequestBodyMatchConditionParametersTypeNameValues returns the possible values for the RequestBodyMatchConditionParametersTypeName const type.

type RequestBodyOperator 

type RequestBodyOperator string

RequestBodyOperator - Describes operator to be matched 

const (
	RequestBodyOperatorAny                RequestBodyOperator = "Any"
	RequestBodyOperatorBeginsWith         RequestBodyOperator = "BeginsWith"
	RequestBodyOperatorContains           RequestBodyOperator = "Contains"
	RequestBodyOperatorEndsWith           RequestBodyOperator = "EndsWith"
	RequestBodyOperatorEqual              RequestBodyOperator = "Equal"
	RequestBodyOperatorGreaterThan        RequestBodyOperator = "GreaterThan"
	RequestBodyOperatorGreaterThanOrEqual RequestBodyOperator = "GreaterThanOrEqual"
	RequestBodyOperatorLessThan           RequestBodyOperator = "LessThan"
	RequestBodyOperatorLessThanOrEqual    RequestBodyOperator = "LessThanOrEqual"
	RequestBodyOperatorRegEx              RequestBodyOperator = "RegEx"
)

func PossibleRequestBodyOperatorValues 

func PossibleRequestBodyOperatorValues() []RequestBodyOperator

PossibleRequestBodyOperatorValues returns the possible values for the RequestBodyOperator const type.

type RequestHeaderMatchConditionParameters 

type RequestHeaderMatchConditionParameters struct {
	// REQUIRED; Describes operator to be matched
	Operator *RequestHeaderOperator

	// REQUIRED
	TypeName *RequestHeaderMatchConditionParametersTypeName

	// The match value for the condition of the delivery rule
	MatchValues []*string

	// Describes if this is negate condition or not
	NegateCondition *bool

	// Name of Header to be matched
	Selector *string

	// List of transforms
	Transforms []*Transform
}

RequestHeaderMatchConditionParameters - Defines the parameters for RequestHeader match conditions

func (RequestHeaderMatchConditionParameters) MarshalJSON 

func (r RequestHeaderMatchConditionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RequestHeaderMatchConditionParameters.

func (*RequestHeaderMatchConditionParameters) UnmarshalJSON 

func (r *RequestHeaderMatchConditionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RequestHeaderMatchConditionParameters.

type RequestHeaderMatchConditionParametersTypeName 

type RequestHeaderMatchConditionParametersTypeName string
const (
	RequestHeaderMatchConditionParametersTypeNameDeliveryRuleRequestHeaderConditionParameters RequestHeaderMatchConditionParametersTypeName = "DeliveryRuleRequestHeaderConditionParameters"
)

func PossibleRequestHeaderMatchConditionParametersTypeNameValues 

func PossibleRequestHeaderMatchConditionParametersTypeNameValues() []RequestHeaderMatchConditionParametersTypeName

PossibleRequestHeaderMatchConditionParametersTypeNameValues returns the possible values for the RequestHeaderMatchConditionParametersTypeName const type.

type RequestHeaderOperator 

type RequestHeaderOperator string

RequestHeaderOperator - Describes operator to be matched 

const (
	RequestHeaderOperatorAny                RequestHeaderOperator = "Any"
	RequestHeaderOperatorBeginsWith         RequestHeaderOperator = "BeginsWith"
	RequestHeaderOperatorContains           RequestHeaderOperator = "Contains"
	RequestHeaderOperatorEndsWith           RequestHeaderOperator = "EndsWith"
	RequestHeaderOperatorEqual              RequestHeaderOperator = "Equal"
	RequestHeaderOperatorGreaterThan        RequestHeaderOperator = "GreaterThan"
	RequestHeaderOperatorGreaterThanOrEqual RequestHeaderOperator = "GreaterThanOrEqual"
	RequestHeaderOperatorLessThan           RequestHeaderOperator = "LessThan"
	RequestHeaderOperatorLessThanOrEqual    RequestHeaderOperator = "LessThanOrEqual"
	RequestHeaderOperatorRegEx              RequestHeaderOperator = "RegEx"
)

func PossibleRequestHeaderOperatorValues 

func PossibleRequestHeaderOperatorValues() []RequestHeaderOperator

PossibleRequestHeaderOperatorValues returns the possible values for the RequestHeaderOperator const type.

type RequestMethodMatchConditionParameters 

type RequestMethodMatchConditionParameters struct {
	// REQUIRED; Describes operator to be matched
	Operator *RequestMethodOperator

	// REQUIRED
	TypeName *RequestMethodMatchConditionParametersTypeName

	// The match value for the condition of the delivery rule
	MatchValues []*RequestMethodMatchConditionParametersMatchValuesItem

	// Describes if this is negate condition or not
	NegateCondition *bool

	// List of transforms
	Transforms []*Transform
}

RequestMethodMatchConditionParameters - Defines the parameters for RequestMethod match conditions

func (RequestMethodMatchConditionParameters) MarshalJSON 

func (r RequestMethodMatchConditionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RequestMethodMatchConditionParameters.

func (*RequestMethodMatchConditionParameters) UnmarshalJSON 

func (r *RequestMethodMatchConditionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RequestMethodMatchConditionParameters.

type RequestMethodMatchConditionParametersMatchValuesItem 

type RequestMethodMatchConditionParametersMatchValuesItem string
const (
	RequestMethodMatchConditionParametersMatchValuesItemDELETE  RequestMethodMatchConditionParametersMatchValuesItem = "DELETE"
	RequestMethodMatchConditionParametersMatchValuesItemGET     RequestMethodMatchConditionParametersMatchValuesItem = "GET"
	RequestMethodMatchConditionParametersMatchValuesItemHEAD    RequestMethodMatchConditionParametersMatchValuesItem = "HEAD"
	RequestMethodMatchConditionParametersMatchValuesItemOPTIONS RequestMethodMatchConditionParametersMatchValuesItem = "OPTIONS"
	RequestMethodMatchConditionParametersMatchValuesItemPOST    RequestMethodMatchConditionParametersMatchValuesItem = "POST"
	RequestMethodMatchConditionParametersMatchValuesItemPUT     RequestMethodMatchConditionParametersMatchValuesItem = "PUT"
	RequestMethodMatchConditionParametersMatchValuesItemTRACE   RequestMethodMatchConditionParametersMatchValuesItem = "TRACE"
)

func PossibleRequestMethodMatchConditionParametersMatchValuesItemValues 

func PossibleRequestMethodMatchConditionParametersMatchValuesItemValues() []RequestMethodMatchConditionParametersMatchValuesItem

PossibleRequestMethodMatchConditionParametersMatchValuesItemValues returns the possible values for the RequestMethodMatchConditionParametersMatchValuesItem const type.

type RequestMethodMatchConditionParametersTypeName 

type RequestMethodMatchConditionParametersTypeName string
const (
	RequestMethodMatchConditionParametersTypeNameDeliveryRuleRequestMethodConditionParameters RequestMethodMatchConditionParametersTypeName = "DeliveryRuleRequestMethodConditionParameters"
)

func PossibleRequestMethodMatchConditionParametersTypeNameValues 

func PossibleRequestMethodMatchConditionParametersTypeNameValues() []RequestMethodMatchConditionParametersTypeName

PossibleRequestMethodMatchConditionParametersTypeNameValues returns the possible values for the RequestMethodMatchConditionParametersTypeName const type.

type RequestMethodOperator 

type RequestMethodOperator string

RequestMethodOperator - Describes operator to be matched 

const (
	RequestMethodOperatorEqual RequestMethodOperator = "Equal"
)

func PossibleRequestMethodOperatorValues 

func PossibleRequestMethodOperatorValues() []RequestMethodOperator

PossibleRequestMethodOperatorValues returns the possible values for the RequestMethodOperator const type.

type RequestSchemeMatchConditionParameters 

type RequestSchemeMatchConditionParameters struct {
	// REQUIRED; Describes operator to be matched
	Operator *RequestSchemeMatchConditionParametersOperator

	// REQUIRED
	TypeName *RequestSchemeMatchConditionParametersTypeName

	// The match value for the condition of the delivery rule
	MatchValues []*RequestSchemeMatchConditionParametersMatchValuesItem

	// Describes if this is negate condition or not
	NegateCondition *bool

	// List of transforms
	Transforms []*Transform
}

RequestSchemeMatchConditionParameters - Defines the parameters for RequestScheme match conditions

func (RequestSchemeMatchConditionParameters) MarshalJSON 

func (r RequestSchemeMatchConditionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RequestSchemeMatchConditionParameters.

func (*RequestSchemeMatchConditionParameters) UnmarshalJSON 

func (r *RequestSchemeMatchConditionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RequestSchemeMatchConditionParameters.

type RequestSchemeMatchConditionParametersMatchValuesItem 

type RequestSchemeMatchConditionParametersMatchValuesItem string
const (
	RequestSchemeMatchConditionParametersMatchValuesItemHTTP  RequestSchemeMatchConditionParametersMatchValuesItem = "HTTP"
	RequestSchemeMatchConditionParametersMatchValuesItemHTTPS RequestSchemeMatchConditionParametersMatchValuesItem = "HTTPS"
)

func PossibleRequestSchemeMatchConditionParametersMatchValuesItemValues 

func PossibleRequestSchemeMatchConditionParametersMatchValuesItemValues() []RequestSchemeMatchConditionParametersMatchValuesItem

PossibleRequestSchemeMatchConditionParametersMatchValuesItemValues returns the possible values for the RequestSchemeMatchConditionParametersMatchValuesItem const type.

type RequestSchemeMatchConditionParametersOperator 

type RequestSchemeMatchConditionParametersOperator string

RequestSchemeMatchConditionParametersOperator - Describes operator to be matched 

const (
	RequestSchemeMatchConditionParametersOperatorEqual RequestSchemeMatchConditionParametersOperator = "Equal"
)

func PossibleRequestSchemeMatchConditionParametersOperatorValues 

func PossibleRequestSchemeMatchConditionParametersOperatorValues() []RequestSchemeMatchConditionParametersOperator

PossibleRequestSchemeMatchConditionParametersOperatorValues returns the possible values for the RequestSchemeMatchConditionParametersOperator const type.

type RequestSchemeMatchConditionParametersTypeName 

type RequestSchemeMatchConditionParametersTypeName string
const (
	RequestSchemeMatchConditionParametersTypeNameDeliveryRuleRequestSchemeConditionParameters RequestSchemeMatchConditionParametersTypeName = "DeliveryRuleRequestSchemeConditionParameters"
)

func PossibleRequestSchemeMatchConditionParametersTypeNameValues 

func PossibleRequestSchemeMatchConditionParametersTypeNameValues() []RequestSchemeMatchConditionParametersTypeName

PossibleRequestSchemeMatchConditionParametersTypeNameValues returns the possible values for the RequestSchemeMatchConditionParametersTypeName const type.

type RequestURIMatchConditionParameters 

type RequestURIMatchConditionParameters struct {
	// REQUIRED; Describes operator to be matched
	Operator *RequestURIOperator

	// REQUIRED
	TypeName *RequestURIMatchConditionParametersTypeName

	// The match value for the condition of the delivery rule
	MatchValues []*string

	// Describes if this is negate condition or not
	NegateCondition *bool

	// List of transforms
	Transforms []*Transform
}

RequestURIMatchConditionParameters - Defines the parameters for RequestUri match conditions

func (RequestURIMatchConditionParameters) MarshalJSON 

func (r RequestURIMatchConditionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RequestURIMatchConditionParameters.

func (*RequestURIMatchConditionParameters) UnmarshalJSON 

func (r *RequestURIMatchConditionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RequestURIMatchConditionParameters.

type RequestURIMatchConditionParametersTypeName 

type RequestURIMatchConditionParametersTypeName string
const (
	RequestURIMatchConditionParametersTypeNameDeliveryRuleRequestURIConditionParameters RequestURIMatchConditionParametersTypeName = "DeliveryRuleRequestUriConditionParameters"
)

func PossibleRequestURIMatchConditionParametersTypeNameValues 

func PossibleRequestURIMatchConditionParametersTypeNameValues() []RequestURIMatchConditionParametersTypeName

PossibleRequestURIMatchConditionParametersTypeNameValues returns the possible values for the RequestURIMatchConditionParametersTypeName const type.

type RequestURIOperator 

type RequestURIOperator string

RequestURIOperator - Describes operator to be matched 

const (
	RequestURIOperatorAny                RequestURIOperator = "Any"
	RequestURIOperatorBeginsWith         RequestURIOperator = "BeginsWith"
	RequestURIOperatorContains           RequestURIOperator = "Contains"
	RequestURIOperatorEndsWith           RequestURIOperator = "EndsWith"
	RequestURIOperatorEqual              RequestURIOperator = "Equal"
	RequestURIOperatorGreaterThan        RequestURIOperator = "GreaterThan"
	RequestURIOperatorGreaterThanOrEqual RequestURIOperator = "GreaterThanOrEqual"
	RequestURIOperatorLessThan           RequestURIOperator = "LessThan"
	RequestURIOperatorLessThanOrEqual    RequestURIOperator = "LessThanOrEqual"
	RequestURIOperatorRegEx              RequestURIOperator = "RegEx"
)

func PossibleRequestURIOperatorValues 

func PossibleRequestURIOperatorValues() []RequestURIOperator

PossibleRequestURIOperatorValues returns the possible values for the RequestURIOperator const type.

type ResourceReference 

type ResourceReference struct {
	// Resource ID.
	ID *string
}

ResourceReference - Reference to another resource.

func (ResourceReference) MarshalJSON 

func (r ResourceReference) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceReference.

func (*ResourceReference) UnmarshalJSON 

func (r *ResourceReference) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceReference.

type ResourceType 

type ResourceType string

ResourceType - Type of CDN resource used in CheckNameAvailability. 

const (
	ResourceTypeMicrosoftCdnProfilesAfdEndpoints ResourceType = "Microsoft.Cdn/Profiles/AfdEndpoints"
	ResourceTypeMicrosoftCdnProfilesEndpoints    ResourceType = "Microsoft.Cdn/Profiles/Endpoints"
)

func PossibleResourceTypeValues 

func PossibleResourceTypeValues() []ResourceType

PossibleResourceTypeValues returns the possible values for the ResourceType const type.

type ResourceUsage 

type ResourceUsage struct {
	// READ-ONLY; Actual value of usage on the specified resource type.
	CurrentValue *int32

	// READ-ONLY; Quota of the specified resource type.
	Limit *int32

	// READ-ONLY; Resource type for which the usage is provided.
	ResourceType *string

	// READ-ONLY; Unit of the usage. e.g. count.
	Unit *ResourceUsageUnit
}

ResourceUsage - Output of check resource usage API.

func (ResourceUsage) MarshalJSON 

func (r ResourceUsage) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceUsage.

func (*ResourceUsage) UnmarshalJSON 

func (r *ResourceUsage) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceUsage.

type ResourceUsageClient 

type ResourceUsageClient struct {
	// contains filtered or unexported fields
}

ResourceUsageClient contains the methods for the ResourceUsage group. Don't use this type directly, use NewResourceUsageClient() instead.

func NewResourceUsageClient 

func NewResourceUsageClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ResourceUsageClient, error)

NewResourceUsageClient creates a new instance of ResourceUsageClient with the specified values.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ResourceUsageClient) NewListPager 

func (client *ResourceUsageClient) NewListPager(options *ResourceUsageClientListOptions) *runtime.Pager[ResourceUsageClientListResponse]

NewListPager - Check the quota and actual usage of the CDN profiles under the given subscription.

Generated from API version 2024-02-01

  • options - ResourceUsageClientListOptions contains the optional parameters for the ResourceUsageClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/ResourceUsage_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewResourceUsageClient().NewListPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.ResourceUsageListResult = armcdn.ResourceUsageListResult{
	// 	Value: []*armcdn.ResourceUsage{
	// 		{
	// 			CurrentValue: to.Ptr[int32](31),
	// 			Limit: to.Ptr[int32](200),
	// 			ResourceType: to.Ptr("profile"),
	// 			Unit: to.Ptr(armcdn.ResourceUsageUnitCount),
	// 	}},
	// }
}

Output:

type ResourceUsageClientListOptions 

type ResourceUsageClientListOptions struct {
}

ResourceUsageClientListOptions contains the optional parameters for the ResourceUsageClient.NewListPager method.

type ResourceUsageClientListResponse 

type ResourceUsageClientListResponse struct {
	// Output of check resource usage API.
	ResourceUsageListResult
}

ResourceUsageClientListResponse contains the response from method ResourceUsageClient.NewListPager.

type ResourceUsageListResult 

type ResourceUsageListResult struct {
	// URL to get the next set of custom domain objects if there are any.
	NextLink *string

	// READ-ONLY; List of resource usages.
	Value []*ResourceUsage
}

ResourceUsageListResult - Output of check resource usage API.

func (ResourceUsageListResult) MarshalJSON 

func (r ResourceUsageListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceUsageListResult.

func (*ResourceUsageListResult) UnmarshalJSON 

func (r *ResourceUsageListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceUsageListResult.

type ResourceUsageUnit 

type ResourceUsageUnit string

ResourceUsageUnit - Unit of the usage. e.g. count. 

const (
	ResourceUsageUnitCount ResourceUsageUnit = "count"
)

func PossibleResourceUsageUnitValues 

func PossibleResourceUsageUnitValues() []ResourceUsageUnit

PossibleResourceUsageUnitValues returns the possible values for the ResourceUsageUnit const type.

type ResourcesResponse 

type ResourcesResponse struct {
	CustomDomains []*ResourcesResponseCustomDomainsItem
	Endpoints     []*ResourcesResponseEndpointsItem
}

ResourcesResponse - Resources Response

func (ResourcesResponse) MarshalJSON 

func (r ResourcesResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourcesResponse.

func (*ResourcesResponse) UnmarshalJSON 

func (r *ResourcesResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourcesResponse.

type ResourcesResponseCustomDomainsItem 

type ResourcesResponseCustomDomainsItem struct {
	EndpointID *string
	History    *bool
	ID         *string
	Name       *string
}

func (ResourcesResponseCustomDomainsItem) MarshalJSON 

func (r ResourcesResponseCustomDomainsItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourcesResponseCustomDomainsItem.

func (*ResourcesResponseCustomDomainsItem) UnmarshalJSON 

func (r *ResourcesResponseCustomDomainsItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourcesResponseCustomDomainsItem.

type ResourcesResponseEndpointsItem 

type ResourcesResponseEndpointsItem struct {
	CustomDomains []*ResourcesResponseEndpointsPropertiesItemsItem
	History       *bool
	ID            *string
	Name          *string
}

func (ResourcesResponseEndpointsItem) MarshalJSON 

func (r ResourcesResponseEndpointsItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourcesResponseEndpointsItem.

func (*ResourcesResponseEndpointsItem) UnmarshalJSON 

func (r *ResourcesResponseEndpointsItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourcesResponseEndpointsItem.

type ResourcesResponseEndpointsPropertiesItemsItem 

type ResourcesResponseEndpointsPropertiesItemsItem struct {
	EndpointID *string
	History    *bool
	ID         *string
	Name       *string
}

func (ResourcesResponseEndpointsPropertiesItemsItem) MarshalJSON 

func (r ResourcesResponseEndpointsPropertiesItemsItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourcesResponseEndpointsPropertiesItemsItem.

func (*ResourcesResponseEndpointsPropertiesItemsItem) UnmarshalJSON 

func (r *ResourcesResponseEndpointsPropertiesItemsItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourcesResponseEndpointsPropertiesItemsItem.

type ResponseBasedDetectedErrorTypes 

type ResponseBasedDetectedErrorTypes string

ResponseBasedDetectedErrorTypes - Type of response errors for real user requests for which origin will be deemed unhealthy 

const (
	ResponseBasedDetectedErrorTypesNone             ResponseBasedDetectedErrorTypes = "None"
	ResponseBasedDetectedErrorTypesTCPAndHTTPErrors ResponseBasedDetectedErrorTypes = "TcpAndHttpErrors"
	ResponseBasedDetectedErrorTypesTCPErrorsOnly    ResponseBasedDetectedErrorTypes = "TcpErrorsOnly"
)

func PossibleResponseBasedDetectedErrorTypesValues 

func PossibleResponseBasedDetectedErrorTypesValues() []ResponseBasedDetectedErrorTypes

PossibleResponseBasedDetectedErrorTypesValues returns the possible values for the ResponseBasedDetectedErrorTypes const type.

type ResponseBasedOriginErrorDetectionParameters 

type ResponseBasedOriginErrorDetectionParameters struct {
	// The list of Http status code ranges that are considered as server errors for origin and it is marked as unhealthy.
	HTTPErrorRanges []*HTTPErrorRangeParameters

	// Type of response errors for real user requests for which origin will be deemed unhealthy
	ResponseBasedDetectedErrorTypes *ResponseBasedDetectedErrorTypes

	// The percentage of failed requests in the sample where failover should trigger.
	ResponseBasedFailoverThresholdPercentage *int32
}

ResponseBasedOriginErrorDetectionParameters - The JSON object that contains the properties to determine origin health using real requests/responses.

func (ResponseBasedOriginErrorDetectionParameters) MarshalJSON 

func (r ResponseBasedOriginErrorDetectionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResponseBasedOriginErrorDetectionParameters.

func (*ResponseBasedOriginErrorDetectionParameters) UnmarshalJSON 

func (r *ResponseBasedOriginErrorDetectionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResponseBasedOriginErrorDetectionParameters.

type Route 

type Route struct {
	// The JSON object that contains the properties of the Routes to create.
	Properties *RouteProperties

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Read only system data
	SystemData *SystemData

	// READ-ONLY; Resource type.
	Type *string
}

Route - Friendly Routes name mapping to the any Routes or secret related information.

func (Route) MarshalJSON 

func (r Route) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Route.

func (*Route) UnmarshalJSON 

func (r *Route) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Route.

type RouteConfigurationOverrideActionParameters 

type RouteConfigurationOverrideActionParameters struct {
	// REQUIRED
	TypeName *RouteConfigurationOverrideActionParametersTypeName

	// The caching configuration associated with this rule. To disable caching, do not provide a cacheConfiguration object.
	CacheConfiguration *CacheConfiguration

	// A reference to the origin group override configuration. Leave empty to use the default origin group on route.
	OriginGroupOverride *OriginGroupOverride
}

RouteConfigurationOverrideActionParameters - Defines the parameters for the route configuration override action.

func (RouteConfigurationOverrideActionParameters) MarshalJSON 

func (r RouteConfigurationOverrideActionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RouteConfigurationOverrideActionParameters.

func (*RouteConfigurationOverrideActionParameters) UnmarshalJSON 

func (r *RouteConfigurationOverrideActionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RouteConfigurationOverrideActionParameters.

type RouteConfigurationOverrideActionParametersTypeName 

type RouteConfigurationOverrideActionParametersTypeName string
const (
	RouteConfigurationOverrideActionParametersTypeNameDeliveryRuleRouteConfigurationOverrideActionParameters RouteConfigurationOverrideActionParametersTypeName = "DeliveryRuleRouteConfigurationOverrideActionParameters"
)

func PossibleRouteConfigurationOverrideActionParametersTypeNameValues 

func PossibleRouteConfigurationOverrideActionParametersTypeNameValues() []RouteConfigurationOverrideActionParametersTypeName

PossibleRouteConfigurationOverrideActionParametersTypeNameValues returns the possible values for the RouteConfigurationOverrideActionParametersTypeName const type.

type RouteListResult 

type RouteListResult struct {
	// URL to get the next set of route objects if there are any.
	NextLink *string

	// READ-ONLY; List of AzureFrontDoor routes within a profile.
	Value []*Route
}

RouteListResult - Result of the request to list routes. It contains a list of route objects and a URL link to get the next set of results.

func (RouteListResult) MarshalJSON 

func (r RouteListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RouteListResult.

func (*RouteListResult) UnmarshalJSON 

func (r *RouteListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RouteListResult.

type RouteProperties 

type RouteProperties struct {
	// The caching configuration for this route. To disable caching, do not provide a cacheConfiguration object.
	CacheConfiguration *AfdRouteCacheConfiguration

	// Domains referenced by this endpoint.
	CustomDomains []*ActivatedResourceReference

	// Whether to enable use of this rule. Permitted values are 'Enabled' or 'Disabled'
	EnabledState *EnabledState

	// Protocol this rule will use when forwarding traffic to backends.
	ForwardingProtocol *ForwardingProtocol

	// Whether to automatically redirect HTTP traffic to HTTPS traffic. Note that this is a easy way to set up this rule and it
	// will be the first rule that gets executed.
	HTTPSRedirect *HTTPSRedirect

	// whether this route will be linked to the default endpoint domain.
	LinkToDefaultDomain *LinkToDefaultDomain

	// A reference to the origin group.
	OriginGroup *ResourceReference

	// A directory path on the origin that AzureFrontDoor can use to retrieve content from, e.g. contoso.cloudapp.net/originpath.
	OriginPath *string

	// The route patterns of the rule.
	PatternsToMatch []*string

	// rule sets referenced by this endpoint.
	RuleSets []*ResourceReference

	// List of supported protocols for this route.
	SupportedProtocols []*AFDEndpointProtocols

	// READ-ONLY
	DeploymentStatus *DeploymentStatus

	// READ-ONLY; The name of the endpoint which holds the route.
	EndpointName *string

	// READ-ONLY; Provisioning status
	ProvisioningState *AfdProvisioningState
}

RouteProperties - The JSON object that contains the properties of the Routes to create.

func (RouteProperties) MarshalJSON 

func (r RouteProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RouteProperties.

func (*RouteProperties) UnmarshalJSON 

func (r *RouteProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RouteProperties.

type RouteUpdateParameters 

type RouteUpdateParameters struct {
	// The JSON object that contains the properties of the domain to create.
	Properties *RouteUpdatePropertiesParameters
}

RouteUpdateParameters - The domain JSON object required for domain creation or update.

func (RouteUpdateParameters) MarshalJSON 

func (r RouteUpdateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RouteUpdateParameters.

func (*RouteUpdateParameters) UnmarshalJSON 

func (r *RouteUpdateParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RouteUpdateParameters.

type RouteUpdatePropertiesParameters 

type RouteUpdatePropertiesParameters struct {
	// The caching configuration for this route. To disable caching, do not provide a cacheConfiguration object.
	CacheConfiguration *AfdRouteCacheConfiguration

	// Domains referenced by this endpoint.
	CustomDomains []*ActivatedResourceReference

	// Whether to enable use of this rule. Permitted values are 'Enabled' or 'Disabled'
	EnabledState *EnabledState

	// Protocol this rule will use when forwarding traffic to backends.
	ForwardingProtocol *ForwardingProtocol

	// Whether to automatically redirect HTTP traffic to HTTPS traffic. Note that this is a easy way to set up this rule and it
	// will be the first rule that gets executed.
	HTTPSRedirect *HTTPSRedirect

	// whether this route will be linked to the default endpoint domain.
	LinkToDefaultDomain *LinkToDefaultDomain

	// A reference to the origin group.
	OriginGroup *ResourceReference

	// A directory path on the origin that AzureFrontDoor can use to retrieve content from, e.g. contoso.cloudapp.net/originpath.
	OriginPath *string

	// The route patterns of the rule.
	PatternsToMatch []*string

	// rule sets referenced by this endpoint.
	RuleSets []*ResourceReference

	// List of supported protocols for this route.
	SupportedProtocols []*AFDEndpointProtocols

	// READ-ONLY; The name of the endpoint which holds the route.
	EndpointName *string
}

RouteUpdatePropertiesParameters - The JSON object that contains the properties of the domain to create.

func (RouteUpdatePropertiesParameters) MarshalJSON 

func (r RouteUpdatePropertiesParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RouteUpdatePropertiesParameters.

func (*RouteUpdatePropertiesParameters) UnmarshalJSON 

func (r *RouteUpdatePropertiesParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RouteUpdatePropertiesParameters.

type RoutesClient 

type RoutesClient struct {
	// contains filtered or unexported fields
}

RoutesClient contains the methods for the Routes group. Don't use this type directly, use NewRoutesClient() instead.

func NewRoutesClient 

func NewRoutesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*RoutesClient, error)

NewRoutesClient creates a new instance of RoutesClient with the specified values.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*RoutesClient) BeginCreate 

func (client *RoutesClient) BeginCreate(ctx context.Context, resourceGroupName string, profileName string, endpointName string, routeName string, route Route, options *RoutesClientBeginCreateOptions) (*runtime.Poller[RoutesClientCreateResponse], error)

BeginCreate - Creates a new route with the specified route name under the specified subscription, resource group, profile, and AzureFrontDoor endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • routeName - Name of the routing rule.
  • route - Route properties
  • options - RoutesClientBeginCreateOptions contains the optional parameters for the RoutesClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Routes_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewRoutesClient().BeginCreate(ctx, "RG", "profile1", "endpoint1", "route1", armcdn.Route{
	Properties: &armcdn.RouteProperties{
		CacheConfiguration: &armcdn.AfdRouteCacheConfiguration{
			CompressionSettings: &armcdn.CompressionSettings{
				ContentTypesToCompress: []*string{
					to.Ptr("text/html"),
					to.Ptr("application/octet-stream")},
				IsCompressionEnabled: to.Ptr(true),
			},
			QueryParameters:            to.Ptr("querystring=test"),
			QueryStringCachingBehavior: to.Ptr(armcdn.AfdQueryStringCachingBehaviorIgnoreSpecifiedQueryStrings),
		},
		CustomDomains: []*armcdn.ActivatedResourceReference{
			{
				ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/customDomains/domain1"),
			}},
		EnabledState:        to.Ptr(armcdn.EnabledStateEnabled),
		ForwardingProtocol:  to.Ptr(armcdn.ForwardingProtocolMatchRequest),
		HTTPSRedirect:       to.Ptr(armcdn.HTTPSRedirectEnabled),
		LinkToDefaultDomain: to.Ptr(armcdn.LinkToDefaultDomainEnabled),
		OriginGroup: &armcdn.ResourceReference{
			ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/originGroups/originGroup1"),
		},
		PatternsToMatch: []*string{
			to.Ptr("/*")},
		RuleSets: []*armcdn.ResourceReference{
			{
				ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/ruleSets/ruleSet1"),
			}},
		SupportedProtocols: []*armcdn.AFDEndpointProtocols{
			to.Ptr(armcdn.AFDEndpointProtocolsHTTPS),
			to.Ptr(armcdn.AFDEndpointProtocolsHTTP)},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Route = armcdn.Route{
// 	Name: to.Ptr("route1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/afdendpoints/routes"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/afdendpoints/endpoint1/routes/route1"),
// 	Properties: &armcdn.RouteProperties{
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 		CacheConfiguration: &armcdn.AfdRouteCacheConfiguration{
// 			CompressionSettings: &armcdn.CompressionSettings{
// 				ContentTypesToCompress: []*string{
// 					to.Ptr("text/html"),
// 					to.Ptr("application/octet-stream")},
// 					IsCompressionEnabled: to.Ptr(true),
// 				},
// 				QueryParameters: to.Ptr("querystring=test"),
// 				QueryStringCachingBehavior: to.Ptr(armcdn.AfdQueryStringCachingBehaviorIgnoreSpecifiedQueryStrings),
// 			},
// 			CustomDomains: []*armcdn.ActivatedResourceReference{
// 				{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/customDomains/domain1"),
// 			}},
// 			EnabledState: to.Ptr(armcdn.EnabledStateEnabled),
// 			ForwardingProtocol: to.Ptr(armcdn.ForwardingProtocolMatchRequest),
// 			HTTPSRedirect: to.Ptr(armcdn.HTTPSRedirectEnabled),
// 			LinkToDefaultDomain: to.Ptr(armcdn.LinkToDefaultDomainEnabled),
// 			OriginGroup: &armcdn.ResourceReference{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/originGroups/originGroup1"),
// 			},
// 			PatternsToMatch: []*string{
// 				to.Ptr("/*")},
// 				RuleSets: []*armcdn.ResourceReference{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/ruleSets/ruleSet1"),
// 				}},
// 				SupportedProtocols: []*armcdn.AFDEndpointProtocols{
// 					to.Ptr(armcdn.AFDEndpointProtocolsHTTPS),
// 					to.Ptr(armcdn.AFDEndpointProtocolsHTTP)},
// 				},
// 			}

Output:

func (*RoutesClient) BeginDelete 

func (client *RoutesClient) BeginDelete(ctx context.Context, resourceGroupName string, profileName string, endpointName string, routeName string, options *RoutesClientBeginDeleteOptions) (*runtime.Poller[RoutesClientDeleteResponse], error)

BeginDelete - Deletes an existing route with the specified route name under the specified subscription, resource group, profile, and AzureFrontDoor endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • routeName - Name of the routing rule.
  • options - RoutesClientBeginDeleteOptions contains the optional parameters for the RoutesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Routes_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewRoutesClient().BeginDelete(ctx, "RG", "profile1", "endpoint1", "route1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*RoutesClient) BeginUpdate 

func (client *RoutesClient) BeginUpdate(ctx context.Context, resourceGroupName string, profileName string, endpointName string, routeName string, routeUpdateProperties RouteUpdateParameters, options *RoutesClientBeginUpdateOptions) (*runtime.Poller[RoutesClientUpdateResponse], error)

BeginUpdate - Updates an existing route with the specified route name under the specified subscription, resource group, profile, and AzureFrontDoor endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • routeName - Name of the routing rule.
  • routeUpdateProperties - Route update properties
  • options - RoutesClientBeginUpdateOptions contains the optional parameters for the RoutesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Routes_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewRoutesClient().BeginUpdate(ctx, "RG", "profile1", "endpoint1", "route1", armcdn.RouteUpdateParameters{
	Properties: &armcdn.RouteUpdatePropertiesParameters{
		CacheConfiguration: &armcdn.AfdRouteCacheConfiguration{
			CompressionSettings: &armcdn.CompressionSettings{
				ContentTypesToCompress: []*string{
					to.Ptr("text/html"),
					to.Ptr("application/octet-stream")},
				IsCompressionEnabled: to.Ptr(true),
			},
			QueryStringCachingBehavior: to.Ptr(armcdn.AfdQueryStringCachingBehaviorIgnoreQueryString),
		},
		CustomDomains: []*armcdn.ActivatedResourceReference{
			{
				ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/customDomains/domain1"),
			}},
		EnabledState:        to.Ptr(armcdn.EnabledStateEnabled),
		ForwardingProtocol:  to.Ptr(armcdn.ForwardingProtocolMatchRequest),
		HTTPSRedirect:       to.Ptr(armcdn.HTTPSRedirectEnabled),
		LinkToDefaultDomain: to.Ptr(armcdn.LinkToDefaultDomainEnabled),
		OriginGroup: &armcdn.ResourceReference{
			ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/originGroups/originGroup1"),
		},
		PatternsToMatch: []*string{
			to.Ptr("/*")},
		RuleSets: []*armcdn.ResourceReference{
			{
				ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/ruleSets/ruleSet1"),
			}},
		SupportedProtocols: []*armcdn.AFDEndpointProtocols{
			to.Ptr(armcdn.AFDEndpointProtocolsHTTPS),
			to.Ptr(armcdn.AFDEndpointProtocolsHTTP)},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Route = armcdn.Route{
// 	Name: to.Ptr("route1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/afdendpoints/routes"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/afdendpoints/endpoint1/routes/route1"),
// 	Properties: &armcdn.RouteProperties{
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 		CacheConfiguration: &armcdn.AfdRouteCacheConfiguration{
// 			CompressionSettings: &armcdn.CompressionSettings{
// 				ContentTypesToCompress: []*string{
// 					to.Ptr("text/html"),
// 					to.Ptr("application/octet-stream")},
// 					IsCompressionEnabled: to.Ptr(true),
// 				},
// 				QueryStringCachingBehavior: to.Ptr(armcdn.AfdQueryStringCachingBehaviorIgnoreQueryString),
// 			},
// 			CustomDomains: []*armcdn.ActivatedResourceReference{
// 				{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/customDomains/domain1"),
// 			}},
// 			EnabledState: to.Ptr(armcdn.EnabledStateEnabled),
// 			ForwardingProtocol: to.Ptr(armcdn.ForwardingProtocolMatchRequest),
// 			HTTPSRedirect: to.Ptr(armcdn.HTTPSRedirectEnabled),
// 			LinkToDefaultDomain: to.Ptr(armcdn.LinkToDefaultDomainEnabled),
// 			OriginGroup: &armcdn.ResourceReference{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/originGroups/originGroup1"),
// 			},
// 			PatternsToMatch: []*string{
// 				to.Ptr("/*")},
// 				RuleSets: []*armcdn.ResourceReference{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/ruleSets/ruleSet1"),
// 				}},
// 				SupportedProtocols: []*armcdn.AFDEndpointProtocols{
// 					to.Ptr(armcdn.AFDEndpointProtocolsHTTPS),
// 					to.Ptr(armcdn.AFDEndpointProtocolsHTTP)},
// 				},
// 			}

Output:

func (*RoutesClient) Get 

func (client *RoutesClient) Get(ctx context.Context, resourceGroupName string, profileName string, endpointName string, routeName string, options *RoutesClientGetOptions) (RoutesClientGetResponse, error)

Get - Gets an existing route with the specified route name under the specified subscription, resource group, profile, and AzureFrontDoor endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • routeName - Name of the routing rule.
  • options - RoutesClientGetOptions contains the optional parameters for the RoutesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Routes_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewRoutesClient().Get(ctx, "RG", "profile1", "endpoint1", "route1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Route = armcdn.Route{
// 	Name: to.Ptr("route1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/afdendpoints/routes"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/afdendpoints/endpoint1/routes/route1"),
// 	Properties: &armcdn.RouteProperties{
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 		CacheConfiguration: &armcdn.AfdRouteCacheConfiguration{
// 			CompressionSettings: &armcdn.CompressionSettings{
// 				ContentTypesToCompress: []*string{
// 					to.Ptr("text/html"),
// 					to.Ptr("application/octet-stream")},
// 					IsCompressionEnabled: to.Ptr(true),
// 				},
// 				QueryStringCachingBehavior: to.Ptr(armcdn.AfdQueryStringCachingBehaviorIgnoreQueryString),
// 			},
// 			CustomDomains: []*armcdn.ActivatedResourceReference{
// 				{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/customDomains/domain1"),
// 			}},
// 			EnabledState: to.Ptr(armcdn.EnabledStateEnabled),
// 			ForwardingProtocol: to.Ptr(armcdn.ForwardingProtocolMatchRequest),
// 			HTTPSRedirect: to.Ptr(armcdn.HTTPSRedirectEnabled),
// 			LinkToDefaultDomain: to.Ptr(armcdn.LinkToDefaultDomainEnabled),
// 			OriginGroup: &armcdn.ResourceReference{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/originGroups/originGroup1"),
// 			},
// 			PatternsToMatch: []*string{
// 				to.Ptr("/*")},
// 				RuleSets: []*armcdn.ResourceReference{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/ruleSets/ruleSet1"),
// 				}},
// 				SupportedProtocols: []*armcdn.AFDEndpointProtocols{
// 					to.Ptr(armcdn.AFDEndpointProtocolsHTTPS),
// 					to.Ptr(armcdn.AFDEndpointProtocolsHTTP)},
// 				},
// 			}

Output:

func (*RoutesClient) NewListByEndpointPager 

func (client *RoutesClient) NewListByEndpointPager(resourceGroupName string, profileName string, endpointName string, options *RoutesClientListByEndpointOptions) *runtime.Pager[RoutesClientListByEndpointResponse]

NewListByEndpointPager - Lists all of the existing origins within a profile.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • endpointName - Name of the endpoint under the profile which is unique globally.
  • options - RoutesClientListByEndpointOptions contains the optional parameters for the RoutesClient.NewListByEndpointPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Routes_ListByEndpoint.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewRoutesClient().NewListByEndpointPager("RG", "profile1", "endpoint1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.RouteListResult = armcdn.RouteListResult{
	// 	Value: []*armcdn.Route{
	// 		{
	// 			Name: to.Ptr("route1"),
	// 			Type: to.Ptr("Microsoft.Cdn/profiles/afdendpoints/routes"),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/afdendpoints/endpoint1/routes/route1"),
	// 			Properties: &armcdn.RouteProperties{
	// 				DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
	// 				ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
	// 				CacheConfiguration: &armcdn.AfdRouteCacheConfiguration{
	// 					CompressionSettings: &armcdn.CompressionSettings{
	// 						ContentTypesToCompress: []*string{
	// 							to.Ptr("text/html"),
	// 							to.Ptr("application/octet-stream")},
	// 							IsCompressionEnabled: to.Ptr(true),
	// 						},
	// 						QueryStringCachingBehavior: to.Ptr(armcdn.AfdQueryStringCachingBehaviorIgnoreQueryString),
	// 					},
	// 					CustomDomains: []*armcdn.ActivatedResourceReference{
	// 						{
	// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/customDomains/domain1"),
	// 					}},
	// 					EnabledState: to.Ptr(armcdn.EnabledStateEnabled),
	// 					ForwardingProtocol: to.Ptr(armcdn.ForwardingProtocolMatchRequest),
	// 					HTTPSRedirect: to.Ptr(armcdn.HTTPSRedirectEnabled),
	// 					LinkToDefaultDomain: to.Ptr(armcdn.LinkToDefaultDomainEnabled),
	// 					OriginGroup: &armcdn.ResourceReference{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/originGroups/originGroup1"),
	// 					},
	// 					PatternsToMatch: []*string{
	// 						to.Ptr("/*")},
	// 						RuleSets: []*armcdn.ResourceReference{
	// 							{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/RG/providers/Microsoft.Cdn/profiles/profile1/ruleSets/ruleSet1"),
	// 						}},
	// 						SupportedProtocols: []*armcdn.AFDEndpointProtocols{
	// 							to.Ptr(armcdn.AFDEndpointProtocolsHTTPS),
	// 							to.Ptr(armcdn.AFDEndpointProtocolsHTTP)},
	// 						},
	// 				}},
	// 			}
}

Output:

type RoutesClientBeginCreateOptions 

type RoutesClientBeginCreateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

RoutesClientBeginCreateOptions contains the optional parameters for the RoutesClient.BeginCreate method.

type RoutesClientBeginDeleteOptions 

type RoutesClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

RoutesClientBeginDeleteOptions contains the optional parameters for the RoutesClient.BeginDelete method.

type RoutesClientBeginUpdateOptions 

type RoutesClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

RoutesClientBeginUpdateOptions contains the optional parameters for the RoutesClient.BeginUpdate method.

type RoutesClientCreateResponse 

type RoutesClientCreateResponse struct {
	// Friendly Routes name mapping to the any Routes or secret related information.
	Route
}

RoutesClientCreateResponse contains the response from method RoutesClient.BeginCreate.

type RoutesClientDeleteResponse 

type RoutesClientDeleteResponse struct {
}

RoutesClientDeleteResponse contains the response from method RoutesClient.BeginDelete.

type RoutesClientGetOptions 

type RoutesClientGetOptions struct {
}

RoutesClientGetOptions contains the optional parameters for the RoutesClient.Get method.

type RoutesClientGetResponse 

type RoutesClientGetResponse struct {
	// Friendly Routes name mapping to the any Routes or secret related information.
	Route
}

RoutesClientGetResponse contains the response from method RoutesClient.Get.

type RoutesClientListByEndpointOptions 

type RoutesClientListByEndpointOptions struct {
}

RoutesClientListByEndpointOptions contains the optional parameters for the RoutesClient.NewListByEndpointPager method.

type RoutesClientListByEndpointResponse 

type RoutesClientListByEndpointResponse struct {
	// Result of the request to list routes. It contains a list of route objects and a URL link to get the next set of results.
	RouteListResult
}

RoutesClientListByEndpointResponse contains the response from method RoutesClient.NewListByEndpointPager.

type RoutesClientUpdateResponse 

type RoutesClientUpdateResponse struct {
	// Friendly Routes name mapping to the any Routes or secret related information.
	Route
}

RoutesClientUpdateResponse contains the response from method RoutesClient.BeginUpdate.

type Rule 

type Rule struct {
	// The JSON object that contains the properties of the Rules to create.
	Properties *RuleProperties

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Read only system data
	SystemData *SystemData

	// READ-ONLY; Resource type.
	Type *string
}

Rule - Friendly Rules name mapping to the any Rules or secret related information.

func (Rule) MarshalJSON 

func (r Rule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Rule.

func (*Rule) UnmarshalJSON 

func (r *Rule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Rule.

type RuleCacheBehavior 

type RuleCacheBehavior string

RuleCacheBehavior - Caching behavior for the requests 

const (
	RuleCacheBehaviorHonorOrigin             RuleCacheBehavior = "HonorOrigin"
	RuleCacheBehaviorOverrideAlways          RuleCacheBehavior = "OverrideAlways"
	RuleCacheBehaviorOverrideIfOriginMissing RuleCacheBehavior = "OverrideIfOriginMissing"
)

func PossibleRuleCacheBehaviorValues 

func PossibleRuleCacheBehaviorValues() []RuleCacheBehavior

PossibleRuleCacheBehaviorValues returns the possible values for the RuleCacheBehavior const type.

type RuleIsCompressionEnabled 

type RuleIsCompressionEnabled string

RuleIsCompressionEnabled - Indicates whether content compression is enabled. If compression is enabled, content will be served as compressed if user requests for a compressed version. Content won't be compressed on AzureFrontDoor when requested content is smaller than 1 byte or larger than 1 MB. 

const (
	RuleIsCompressionEnabledDisabled RuleIsCompressionEnabled = "Disabled"
	RuleIsCompressionEnabledEnabled  RuleIsCompressionEnabled = "Enabled"
)

func PossibleRuleIsCompressionEnabledValues 

func PossibleRuleIsCompressionEnabledValues() []RuleIsCompressionEnabled

PossibleRuleIsCompressionEnabledValues returns the possible values for the RuleIsCompressionEnabled const type.

type RuleListResult 

type RuleListResult struct {
	// URL to get the next set of rule objects if there are any.
	NextLink *string

	// READ-ONLY; List of AzureFrontDoor rules within a rule set.
	Value []*Rule
}

RuleListResult - Result of the request to list rules. It contains a list of rule objects and a URL link to get the next set of results.

func (RuleListResult) MarshalJSON 

func (r RuleListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RuleListResult.

func (*RuleListResult) UnmarshalJSON 

func (r *RuleListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RuleListResult.

type RuleProperties 

type RuleProperties struct {
	// A list of actions that are executed when all the conditions of a rule are satisfied.
	Actions []DeliveryRuleActionAutoGeneratedClassification

	// A list of conditions that must be matched for the actions to be executed
	Conditions []DeliveryRuleConditionClassification

	// If this rule is a match should the rules engine continue running the remaining rules or stop. If not present, defaults
	// to Continue.
	MatchProcessingBehavior *MatchProcessingBehavior

	// The order in which the rules are applied for the endpoint. Possible values {0,1,2,3,………}. A rule with a lesser order will
	// be applied before a rule with a greater order. Rule with order 0 is a special
	// rule. It does not require any condition and actions listed in it will always be applied.
	Order *int32

	// READ-ONLY
	DeploymentStatus *DeploymentStatus

	// READ-ONLY; Provisioning status
	ProvisioningState *AfdProvisioningState

	// READ-ONLY; The name of the rule set containing the rule.
	RuleSetName *string
}

RuleProperties - The JSON object that contains the properties of the Rules to create.

func (RuleProperties) MarshalJSON 

func (r RuleProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RuleProperties.

func (*RuleProperties) UnmarshalJSON 

func (r *RuleProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RuleProperties.

type RuleQueryStringCachingBehavior 

type RuleQueryStringCachingBehavior string

RuleQueryStringCachingBehavior - Defines how Frontdoor caches requests that include query strings. You can ignore any query strings when caching, ignore specific query strings, cache every request with a unique URL, or cache specific query strings. 

const (
	RuleQueryStringCachingBehaviorIgnoreQueryString            RuleQueryStringCachingBehavior = "IgnoreQueryString"
	RuleQueryStringCachingBehaviorIgnoreSpecifiedQueryStrings  RuleQueryStringCachingBehavior = "IgnoreSpecifiedQueryStrings"
	RuleQueryStringCachingBehaviorIncludeSpecifiedQueryStrings RuleQueryStringCachingBehavior = "IncludeSpecifiedQueryStrings"
	RuleQueryStringCachingBehaviorUseQueryString               RuleQueryStringCachingBehavior = "UseQueryString"
)

func PossibleRuleQueryStringCachingBehaviorValues 

func PossibleRuleQueryStringCachingBehaviorValues() []RuleQueryStringCachingBehavior

PossibleRuleQueryStringCachingBehaviorValues returns the possible values for the RuleQueryStringCachingBehavior const type.

type RuleSet 

type RuleSet struct {
	// The JSON object that contains the properties of the Rule Set to create.
	Properties *RuleSetProperties

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Read only system data
	SystemData *SystemData

	// READ-ONLY; Resource type.
	Type *string
}

RuleSet - Friendly RuleSet name mapping to the any RuleSet or secret related information.

func (RuleSet) MarshalJSON 

func (r RuleSet) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RuleSet.

func (*RuleSet) UnmarshalJSON 

func (r *RuleSet) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RuleSet.

type RuleSetListResult 

type RuleSetListResult struct {
	// URL to get the next set of rule set objects if there are any.
	NextLink *string

	// READ-ONLY; List of AzureFrontDoor rule sets within a profile.
	Value []*RuleSet
}

RuleSetListResult - Result of the request to list rule sets. It contains a list of rule set objects and a URL link to get the next set of results.

func (RuleSetListResult) MarshalJSON 

func (r RuleSetListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RuleSetListResult.

func (*RuleSetListResult) UnmarshalJSON 

func (r *RuleSetListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RuleSetListResult.

type RuleSetProperties 

type RuleSetProperties struct {
	// READ-ONLY
	DeploymentStatus *DeploymentStatus

	// READ-ONLY; The name of the profile which holds the rule set.
	ProfileName *string

	// READ-ONLY; Provisioning status
	ProvisioningState *AfdProvisioningState
}

RuleSetProperties - The JSON object that contains the properties of the Rule Set to create.

func (RuleSetProperties) MarshalJSON 

func (r RuleSetProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RuleSetProperties.

func (*RuleSetProperties) UnmarshalJSON 

func (r *RuleSetProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RuleSetProperties.

type RuleSetsClient 

type RuleSetsClient struct {
	// contains filtered or unexported fields
}

RuleSetsClient contains the methods for the RuleSets group. Don't use this type directly, use NewRuleSetsClient() instead.

func NewRuleSetsClient 

func NewRuleSetsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*RuleSetsClient, error)

NewRuleSetsClient creates a new instance of RuleSetsClient with the specified values.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*RuleSetsClient) BeginDelete 

func (client *RuleSetsClient) BeginDelete(ctx context.Context, resourceGroupName string, profileName string, ruleSetName string, options *RuleSetsClientBeginDeleteOptions) (*runtime.Poller[RuleSetsClientDeleteResponse], error)

BeginDelete - Deletes an existing AzureFrontDoor rule set with the specified rule set name under the specified subscription, resource group and profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • ruleSetName - Name of the rule set under the profile which is unique globally.
  • options - RuleSetsClientBeginDeleteOptions contains the optional parameters for the RuleSetsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/RuleSets_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewRuleSetsClient().BeginDelete(ctx, "RG", "profile1", "ruleSet1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*RuleSetsClient) Create 

func (client *RuleSetsClient) Create(ctx context.Context, resourceGroupName string, profileName string, ruleSetName string, options *RuleSetsClientCreateOptions) (RuleSetsClientCreateResponse, error)

Create - Creates a new rule set within the specified profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • ruleSetName - Name of the rule set under the profile which is unique globally
  • options - RuleSetsClientCreateOptions contains the optional parameters for the RuleSetsClient.Create method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/RuleSets_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewRuleSetsClient().Create(ctx, "RG", "profile1", "ruleSet1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.RuleSet = armcdn.RuleSet{
// 	Name: to.Ptr("ruleSet1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/rulesets"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/rulesets/ruleSet1"),
// 	Properties: &armcdn.RuleSetProperties{
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 	},
// }

Output:

func (*RuleSetsClient) Get 

func (client *RuleSetsClient) Get(ctx context.Context, resourceGroupName string, profileName string, ruleSetName string, options *RuleSetsClientGetOptions) (RuleSetsClientGetResponse, error)

Get - Gets an existing AzureFrontDoor rule set with the specified rule set name under the specified subscription, resource group and profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • ruleSetName - Name of the rule set under the profile which is unique globally.
  • options - RuleSetsClientGetOptions contains the optional parameters for the RuleSetsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/RuleSets_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewRuleSetsClient().Get(ctx, "RG", "profile1", "ruleSet1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.RuleSet = armcdn.RuleSet{
// 	Name: to.Ptr("ruleSet1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/rulesets"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/rulesets/ruleSet1"),
// 	Properties: &armcdn.RuleSetProperties{
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 	},
// }

Output:

func (*RuleSetsClient) NewListByProfilePager 

func (client *RuleSetsClient) NewListByProfilePager(resourceGroupName string, profileName string, options *RuleSetsClientListByProfileOptions) *runtime.Pager[RuleSetsClientListByProfileResponse]

NewListByProfilePager - Lists existing AzureFrontDoor rule sets within a profile.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • options - RuleSetsClientListByProfileOptions contains the optional parameters for the RuleSetsClient.NewListByProfilePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/RuleSets_ListByProfile.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewRuleSetsClient().NewListByProfilePager("RG", "profile1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.RuleSetListResult = armcdn.RuleSetListResult{
	// 	Value: []*armcdn.RuleSet{
	// 		{
	// 			Name: to.Ptr("ruleSet1"),
	// 			Type: to.Ptr("Microsoft.Cdn/profiles/rulesets"),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/rulesets/ruleSet1"),
	// 			Properties: &armcdn.RuleSetProperties{
	// 				DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
	// 				ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
	// 			},
	// 	}},
	// }
}

Output:

func (*RuleSetsClient) NewListResourceUsagePager 

func (client *RuleSetsClient) NewListResourceUsagePager(resourceGroupName string, profileName string, ruleSetName string, options *RuleSetsClientListResourceUsageOptions) *runtime.Pager[RuleSetsClientListResourceUsageResponse]

NewListResourceUsagePager - Checks the quota and actual usage of endpoints under the given Azure Front Door profile..

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • ruleSetName - Name of the rule set under the profile which is unique globally.
  • options - RuleSetsClientListResourceUsageOptions contains the optional parameters for the RuleSetsClient.NewListResourceUsagePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/RuleSets_ListResourceUsage.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewRuleSetsClient().NewListResourceUsagePager("RG", "profile1", "ruleSet1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.UsagesListResult = armcdn.UsagesListResult{
	// 	Value: []*armcdn.Usage{
	// 		{
	// 			Name: &armcdn.UsageName{
	// 				LocalizedValue: to.Ptr("rule"),
	// 				Value: to.Ptr("rule"),
	// 			},
	// 			CurrentValue: to.Ptr[int64](0),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/rulesets/ruleSet1/rules/rule1"),
	// 			Limit: to.Ptr[int64](25),
	// 			Unit: to.Ptr(armcdn.UsageUnitCount),
	// 	}},
	// }
}

Output:

type RuleSetsClientBeginDeleteOptions 

type RuleSetsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

RuleSetsClientBeginDeleteOptions contains the optional parameters for the RuleSetsClient.BeginDelete method.

type RuleSetsClientCreateOptions 

type RuleSetsClientCreateOptions struct {
}

RuleSetsClientCreateOptions contains the optional parameters for the RuleSetsClient.Create method.

type RuleSetsClientCreateResponse 

type RuleSetsClientCreateResponse struct {
	// Friendly RuleSet name mapping to the any RuleSet or secret related information.
	RuleSet
}

RuleSetsClientCreateResponse contains the response from method RuleSetsClient.Create.

type RuleSetsClientDeleteResponse 

type RuleSetsClientDeleteResponse struct {
}

RuleSetsClientDeleteResponse contains the response from method RuleSetsClient.BeginDelete.

type RuleSetsClientGetOptions 

type RuleSetsClientGetOptions struct {
}

RuleSetsClientGetOptions contains the optional parameters for the RuleSetsClient.Get method.

type RuleSetsClientGetResponse 

type RuleSetsClientGetResponse struct {
	// Friendly RuleSet name mapping to the any RuleSet or secret related information.
	RuleSet
}

RuleSetsClientGetResponse contains the response from method RuleSetsClient.Get.

type RuleSetsClientListByProfileOptions 

type RuleSetsClientListByProfileOptions struct {
}

RuleSetsClientListByProfileOptions contains the optional parameters for the RuleSetsClient.NewListByProfilePager method.

type RuleSetsClientListByProfileResponse 

type RuleSetsClientListByProfileResponse struct {
	// Result of the request to list rule sets. It contains a list of rule set objects and a URL link to get the next set of results.
	RuleSetListResult
}

RuleSetsClientListByProfileResponse contains the response from method RuleSetsClient.NewListByProfilePager.

type RuleSetsClientListResourceUsageOptions 

type RuleSetsClientListResourceUsageOptions struct {
}

RuleSetsClientListResourceUsageOptions contains the optional parameters for the RuleSetsClient.NewListResourceUsagePager method.

type RuleSetsClientListResourceUsageResponse 

type RuleSetsClientListResourceUsageResponse struct {
	// The list usages operation response.
	UsagesListResult
}

RuleSetsClientListResourceUsageResponse contains the response from method RuleSetsClient.NewListResourceUsagePager.

type RuleUpdateParameters 

type RuleUpdateParameters struct {
	// The JSON object that contains the properties of the rule to update.
	Properties *RuleUpdatePropertiesParameters
}

RuleUpdateParameters - The domain JSON object required for domain creation or update.

func (RuleUpdateParameters) MarshalJSON 

func (r RuleUpdateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RuleUpdateParameters.

func (*RuleUpdateParameters) UnmarshalJSON 

func (r *RuleUpdateParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RuleUpdateParameters.

type RuleUpdatePropertiesParameters 

type RuleUpdatePropertiesParameters struct {
	// A list of actions that are executed when all the conditions of a rule are satisfied.
	Actions []DeliveryRuleActionAutoGeneratedClassification

	// A list of conditions that must be matched for the actions to be executed
	Conditions []DeliveryRuleConditionClassification

	// If this rule is a match should the rules engine continue running the remaining rules or stop. If not present, defaults
	// to Continue.
	MatchProcessingBehavior *MatchProcessingBehavior

	// The order in which the rules are applied for the endpoint. Possible values {0,1,2,3,………}. A rule with a lesser order will
	// be applied before a rule with a greater order. Rule with order 0 is a special
	// rule. It does not require any condition and actions listed in it will always be applied.
	Order *int32

	// READ-ONLY; The name of the rule set containing the rule.
	RuleSetName *string
}

RuleUpdatePropertiesParameters - The JSON object that contains the properties of the rule to update.

func (RuleUpdatePropertiesParameters) MarshalJSON 

func (r RuleUpdatePropertiesParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RuleUpdatePropertiesParameters.

func (*RuleUpdatePropertiesParameters) UnmarshalJSON 

func (r *RuleUpdatePropertiesParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RuleUpdatePropertiesParameters.

type RulesClient 

type RulesClient struct {
	// contains filtered or unexported fields
}

RulesClient contains the methods for the Rules group. Don't use this type directly, use NewRulesClient() instead.

func NewRulesClient 

func NewRulesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*RulesClient, error)

NewRulesClient creates a new instance of RulesClient with the specified values.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*RulesClient) BeginCreate 

func (client *RulesClient) BeginCreate(ctx context.Context, resourceGroupName string, profileName string, ruleSetName string, ruleName string, rule Rule, options *RulesClientBeginCreateOptions) (*runtime.Poller[RulesClientCreateResponse], error)

BeginCreate - Creates a new delivery rule within the specified rule set. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • ruleSetName - Name of the rule set under the profile.
  • ruleName - Name of the delivery rule which is unique within the endpoint.
  • rule - The delivery rule properties.
  • options - RulesClientBeginCreateOptions contains the optional parameters for the RulesClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Rules_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewRulesClient().BeginCreate(ctx, "RG", "profile1", "ruleSet1", "rule1", armcdn.Rule{
	Properties: &armcdn.RuleProperties{
		Actions: []armcdn.DeliveryRuleActionAutoGeneratedClassification{
			&armcdn.DeliveryRuleResponseHeaderAction{
				Name: to.Ptr(armcdn.DeliveryRuleActionModifyResponseHeader),
				Parameters: &armcdn.HeaderActionParameters{
					HeaderAction: to.Ptr(armcdn.HeaderActionOverwrite),
					HeaderName:   to.Ptr("X-CDN"),
					TypeName:     to.Ptr(armcdn.HeaderActionParametersTypeNameDeliveryRuleHeaderActionParameters),
					Value:        to.Ptr("MSFT"),
				},
			}},
		Conditions: []armcdn.DeliveryRuleConditionClassification{
			&armcdn.DeliveryRuleRequestMethodCondition{
				Name: to.Ptr(armcdn.MatchVariableRequestMethod),
				Parameters: &armcdn.RequestMethodMatchConditionParameters{
					MatchValues: []*armcdn.RequestMethodMatchConditionParametersMatchValuesItem{
						to.Ptr(armcdn.RequestMethodMatchConditionParametersMatchValuesItemGET)},
					NegateCondition: to.Ptr(false),
					Operator:        to.Ptr(armcdn.RequestMethodOperatorEqual),
					TypeName:        to.Ptr(armcdn.RequestMethodMatchConditionParametersTypeNameDeliveryRuleRequestMethodConditionParameters),
				},
			}},
		Order: to.Ptr[int32](1),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Rule = armcdn.Rule{
// 	Name: to.Ptr("rule1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/rulesets/rules"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/rulesets/ruleSet1/rules/rule1"),
// 	Properties: &armcdn.RuleProperties{
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 		Actions: []armcdn.DeliveryRuleActionAutoGeneratedClassification{
// 			&armcdn.DeliveryRuleResponseHeaderAction{
// 				Name: to.Ptr(armcdn.DeliveryRuleActionModifyResponseHeader),
// 				Parameters: &armcdn.HeaderActionParameters{
// 					HeaderAction: to.Ptr(armcdn.HeaderActionOverwrite),
// 					HeaderName: to.Ptr("X-CDN"),
// 					TypeName: to.Ptr(armcdn.HeaderActionParametersTypeNameDeliveryRuleHeaderActionParameters),
// 					Value: to.Ptr("MSFT"),
// 				},
// 		}},
// 		Conditions: []armcdn.DeliveryRuleConditionClassification{
// 			&armcdn.DeliveryRuleRequestMethodCondition{
// 				Name: to.Ptr(armcdn.MatchVariableRequestMethod),
// 				Parameters: &armcdn.RequestMethodMatchConditionParameters{
// 					MatchValues: []*armcdn.RequestMethodMatchConditionParametersMatchValuesItem{
// 						to.Ptr(armcdn.RequestMethodMatchConditionParametersMatchValuesItemGET)},
// 						NegateCondition: to.Ptr(false),
// 						Operator: to.Ptr(armcdn.RequestMethodOperatorEqual),
// 						Transforms: []*armcdn.Transform{
// 						},
// 						TypeName: to.Ptr(armcdn.RequestMethodMatchConditionParametersTypeNameDeliveryRuleRequestMethodConditionParameters),
// 					},
// 			}},
// 			MatchProcessingBehavior: to.Ptr(armcdn.MatchProcessingBehaviorContinue),
// 			Order: to.Ptr[int32](1),
// 		},
// 	}

Output:

func (*RulesClient) BeginDelete 

func (client *RulesClient) BeginDelete(ctx context.Context, resourceGroupName string, profileName string, ruleSetName string, ruleName string, options *RulesClientBeginDeleteOptions) (*runtime.Poller[RulesClientDeleteResponse], error)

BeginDelete - Deletes an existing delivery rule within a rule set. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • ruleSetName - Name of the rule set under the profile.
  • ruleName - Name of the delivery rule which is unique within the endpoint.
  • options - RulesClientBeginDeleteOptions contains the optional parameters for the RulesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Rules_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewRulesClient().BeginDelete(ctx, "RG", "profile1", "ruleSet1", "rule1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*RulesClient) BeginUpdate 

func (client *RulesClient) BeginUpdate(ctx context.Context, resourceGroupName string, profileName string, ruleSetName string, ruleName string, ruleUpdateProperties RuleUpdateParameters, options *RulesClientBeginUpdateOptions) (*runtime.Poller[RulesClientUpdateResponse], error)

BeginUpdate - Updates an existing delivery rule within a rule set. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • ruleSetName - Name of the rule set under the profile.
  • ruleName - Name of the delivery rule which is unique within the endpoint.
  • ruleUpdateProperties - Delivery rule properties
  • options - RulesClientBeginUpdateOptions contains the optional parameters for the RulesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Rules_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewRulesClient().BeginUpdate(ctx, "RG", "profile1", "ruleSet1", "rule1", armcdn.RuleUpdateParameters{
	Properties: &armcdn.RuleUpdatePropertiesParameters{
		Actions: []armcdn.DeliveryRuleActionAutoGeneratedClassification{
			&armcdn.DeliveryRuleResponseHeaderAction{
				Name: to.Ptr(armcdn.DeliveryRuleActionModifyResponseHeader),
				Parameters: &armcdn.HeaderActionParameters{
					HeaderAction: to.Ptr(armcdn.HeaderActionOverwrite),
					HeaderName:   to.Ptr("X-CDN"),
					TypeName:     to.Ptr(armcdn.HeaderActionParametersTypeNameDeliveryRuleHeaderActionParameters),
					Value:        to.Ptr("MSFT"),
				},
			}},
		Order: to.Ptr[int32](1),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Rule = armcdn.Rule{
// 	Name: to.Ptr("rule1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/rulesets/rules"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/rulesets/ruleSet1/rules/rule1"),
// 	Properties: &armcdn.RuleProperties{
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 		Actions: []armcdn.DeliveryRuleActionAutoGeneratedClassification{
// 			&armcdn.DeliveryRuleResponseHeaderAction{
// 				Name: to.Ptr(armcdn.DeliveryRuleActionModifyResponseHeader),
// 				Parameters: &armcdn.HeaderActionParameters{
// 					HeaderAction: to.Ptr(armcdn.HeaderActionOverwrite),
// 					HeaderName: to.Ptr("X-CDN"),
// 					TypeName: to.Ptr(armcdn.HeaderActionParametersTypeNameDeliveryRuleHeaderActionParameters),
// 					Value: to.Ptr("MSFT"),
// 				},
// 		}},
// 		Conditions: []armcdn.DeliveryRuleConditionClassification{
// 			&armcdn.DeliveryRuleRequestMethodCondition{
// 				Name: to.Ptr(armcdn.MatchVariableRequestMethod),
// 				Parameters: &armcdn.RequestMethodMatchConditionParameters{
// 					MatchValues: []*armcdn.RequestMethodMatchConditionParametersMatchValuesItem{
// 						to.Ptr(armcdn.RequestMethodMatchConditionParametersMatchValuesItemGET)},
// 						NegateCondition: to.Ptr(false),
// 						Operator: to.Ptr(armcdn.RequestMethodOperatorEqual),
// 						Transforms: []*armcdn.Transform{
// 						},
// 						TypeName: to.Ptr(armcdn.RequestMethodMatchConditionParametersTypeNameDeliveryRuleRequestMethodConditionParameters),
// 					},
// 			}},
// 			MatchProcessingBehavior: to.Ptr(armcdn.MatchProcessingBehaviorContinue),
// 			Order: to.Ptr[int32](1),
// 		},
// 	}

Output:

func (*RulesClient) Get 

func (client *RulesClient) Get(ctx context.Context, resourceGroupName string, profileName string, ruleSetName string, ruleName string, options *RulesClientGetOptions) (RulesClientGetResponse, error)

Get - Gets an existing delivery rule within a rule set. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • ruleSetName - Name of the rule set under the profile.
  • ruleName - Name of the delivery rule which is unique within the endpoint.
  • options - RulesClientGetOptions contains the optional parameters for the RulesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Rules_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewRulesClient().Get(ctx, "RG", "profile1", "ruleSet1", "rule1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Rule = armcdn.Rule{
// 	Name: to.Ptr("rule1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/rulesets/rules"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/rulesets/ruleSet1/rules/rule1"),
// 	Properties: &armcdn.RuleProperties{
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 		Actions: []armcdn.DeliveryRuleActionAutoGeneratedClassification{
// 			&armcdn.DeliveryRuleResponseHeaderAction{
// 				Name: to.Ptr(armcdn.DeliveryRuleActionModifyResponseHeader),
// 				Parameters: &armcdn.HeaderActionParameters{
// 					HeaderAction: to.Ptr(armcdn.HeaderActionOverwrite),
// 					HeaderName: to.Ptr("X-CDN"),
// 					TypeName: to.Ptr(armcdn.HeaderActionParametersTypeNameDeliveryRuleHeaderActionParameters),
// 					Value: to.Ptr("MSFT"),
// 				},
// 		}},
// 		Conditions: []armcdn.DeliveryRuleConditionClassification{
// 			&armcdn.DeliveryRuleRequestMethodCondition{
// 				Name: to.Ptr(armcdn.MatchVariableRequestMethod),
// 				Parameters: &armcdn.RequestMethodMatchConditionParameters{
// 					MatchValues: []*armcdn.RequestMethodMatchConditionParametersMatchValuesItem{
// 						to.Ptr(armcdn.RequestMethodMatchConditionParametersMatchValuesItemGET)},
// 						NegateCondition: to.Ptr(false),
// 						Operator: to.Ptr(armcdn.RequestMethodOperatorEqual),
// 						Transforms: []*armcdn.Transform{
// 						},
// 						TypeName: to.Ptr(armcdn.RequestMethodMatchConditionParametersTypeNameDeliveryRuleRequestMethodConditionParameters),
// 					},
// 			}},
// 			MatchProcessingBehavior: to.Ptr(armcdn.MatchProcessingBehaviorContinue),
// 			Order: to.Ptr[int32](1),
// 		},
// 	}

Output:

func (*RulesClient) NewListByRuleSetPager 

func (client *RulesClient) NewListByRuleSetPager(resourceGroupName string, profileName string, ruleSetName string, options *RulesClientListByRuleSetOptions) *runtime.Pager[RulesClientListByRuleSetResponse]

NewListByRuleSetPager - Lists all of the existing delivery rules within a rule set.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • ruleSetName - Name of the rule set under the profile.
  • options - RulesClientListByRuleSetOptions contains the optional parameters for the RulesClient.NewListByRuleSetPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Rules_ListByRuleSet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewRulesClient().NewListByRuleSetPager("RG", "profile1", "ruleSet1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.RuleListResult = armcdn.RuleListResult{
	// 	Value: []*armcdn.Rule{
	// 		{
	// 			Name: to.Ptr("rule1"),
	// 			Type: to.Ptr("Microsoft.Cdn/profiles/rulesets/rules"),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/rulesets/ruleSet1/rules/rule1"),
	// 			Properties: &armcdn.RuleProperties{
	// 				DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
	// 				ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
	// 				Actions: []armcdn.DeliveryRuleActionAutoGeneratedClassification{
	// 					&armcdn.DeliveryRuleResponseHeaderAction{
	// 						Name: to.Ptr(armcdn.DeliveryRuleActionModifyResponseHeader),
	// 						Parameters: &armcdn.HeaderActionParameters{
	// 							HeaderAction: to.Ptr(armcdn.HeaderActionOverwrite),
	// 							HeaderName: to.Ptr("X-CDN"),
	// 							TypeName: to.Ptr(armcdn.HeaderActionParametersTypeNameDeliveryRuleHeaderActionParameters),
	// 							Value: to.Ptr("MSFT"),
	// 						},
	// 				}},
	// 				Conditions: []armcdn.DeliveryRuleConditionClassification{
	// 					&armcdn.DeliveryRuleRequestMethodCondition{
	// 						Name: to.Ptr(armcdn.MatchVariableRequestMethod),
	// 						Parameters: &armcdn.RequestMethodMatchConditionParameters{
	// 							MatchValues: []*armcdn.RequestMethodMatchConditionParametersMatchValuesItem{
	// 								to.Ptr(armcdn.RequestMethodMatchConditionParametersMatchValuesItemGET)},
	// 								NegateCondition: to.Ptr(false),
	// 								Operator: to.Ptr(armcdn.RequestMethodOperatorEqual),
	// 								Transforms: []*armcdn.Transform{
	// 								},
	// 								TypeName: to.Ptr(armcdn.RequestMethodMatchConditionParametersTypeNameDeliveryRuleRequestMethodConditionParameters),
	// 							},
	// 					}},
	// 					MatchProcessingBehavior: to.Ptr(armcdn.MatchProcessingBehaviorContinue),
	// 					Order: to.Ptr[int32](1),
	// 				},
	// 		}},
	// 	}
}

Output:

type RulesClientBeginCreateOptions 

type RulesClientBeginCreateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

RulesClientBeginCreateOptions contains the optional parameters for the RulesClient.BeginCreate method.

type RulesClientBeginDeleteOptions 

type RulesClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

RulesClientBeginDeleteOptions contains the optional parameters for the RulesClient.BeginDelete method.

type RulesClientBeginUpdateOptions 

type RulesClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

RulesClientBeginUpdateOptions contains the optional parameters for the RulesClient.BeginUpdate method.

type RulesClientCreateResponse 

type RulesClientCreateResponse struct {
	// Friendly Rules name mapping to the any Rules or secret related information.
	Rule
}

RulesClientCreateResponse contains the response from method RulesClient.BeginCreate.

type RulesClientDeleteResponse 

type RulesClientDeleteResponse struct {
}

RulesClientDeleteResponse contains the response from method RulesClient.BeginDelete.

type RulesClientGetOptions 

type RulesClientGetOptions struct {
}

RulesClientGetOptions contains the optional parameters for the RulesClient.Get method.

type RulesClientGetResponse 

type RulesClientGetResponse struct {
	// Friendly Rules name mapping to the any Rules or secret related information.
	Rule
}

RulesClientGetResponse contains the response from method RulesClient.Get.

type RulesClientListByRuleSetOptions 

type RulesClientListByRuleSetOptions struct {
}

RulesClientListByRuleSetOptions contains the optional parameters for the RulesClient.NewListByRuleSetPager method.

type RulesClientListByRuleSetResponse 

type RulesClientListByRuleSetResponse struct {
	// Result of the request to list rules. It contains a list of rule objects and a URL link to get the next set of results.
	RuleListResult
}

RulesClientListByRuleSetResponse contains the response from method RulesClient.NewListByRuleSetPager.

type RulesClientUpdateResponse 

type RulesClientUpdateResponse struct {
	// Friendly Rules name mapping to the any Rules or secret related information.
	Rule
}

RulesClientUpdateResponse contains the response from method RulesClient.BeginUpdate.

type SKU 

type SKU struct {
	// Name of the pricing tier.
	Name *SKUName
}

SKU - StandardVerizon = The SKU name for a Standard Verizon CDN profile. PremiumVerizon = The SKU name for a Premium Verizon CDN profile. CustomVerizon = The SKU name for a Custom Verizon CDN profile. StandardAkamai = The SKU name for an Akamai CDN profile. StandardChinaCdn = The SKU name for a China CDN profile for VOD, Web and download scenarios using GB based billing model. StandardMicrosoft = The SKU name for a Standard Microsoft CDN profile. StandardAzureFrontDoor = The SKU name for an Azure Front Door Standard profile. PremiumAzureFrontDoor = The SKU name for an Azure Front Door Premium profile. Standard955BandWidthChinaCdn = The SKU name for a China CDN profile for VOD, Web and download scenarios using 95-5 peak bandwidth billing model. StandardAvgBandWidthChinaCdn = The SKU name for a China CDN profile for VOD, Web and download scenarios using monthly average peak bandwidth billing model. StandardPlusChinaCdn = The SKU name for a China CDN profile for live-streaming using GB based billing model. StandardPlus955BandWidthChinaCdn = The SKU name for a China CDN live-streaming profile using 95-5 peak bandwidth billing model. StandardPlusAvgBandWidth_ChinaCdn = The SKU name for a China CDN live-streaming profile using monthly average peak bandwidth billing model.

func (SKU) MarshalJSON 

func (s SKU) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SKU.

func (*SKU) UnmarshalJSON 

func (s *SKU) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SKU.

type SKUName 

type SKUName string

SKUName - Name of the pricing tier. 

const (
	SKUNameCustomVerizon                    SKUName = "Custom_Verizon"
	SKUNamePremiumAzureFrontDoor            SKUName = "Premium_AzureFrontDoor"
	SKUNamePremiumVerizon                   SKUName = "Premium_Verizon"
	SKUNameStandard955BandWidthChinaCdn     SKUName = "Standard_955BandWidth_ChinaCdn"
	SKUNameStandardAkamai                   SKUName = "Standard_Akamai"
	SKUNameStandardAvgBandWidthChinaCdn     SKUName = "Standard_AvgBandWidth_ChinaCdn"
	SKUNameStandardAzureFrontDoor           SKUName = "Standard_AzureFrontDoor"
	SKUNameStandardChinaCdn                 SKUName = "Standard_ChinaCdn"
	SKUNameStandardMicrosoft                SKUName = "Standard_Microsoft"
	SKUNameStandardPlus955BandWidthChinaCdn SKUName = "StandardPlus_955BandWidth_ChinaCdn"
	SKUNameStandardPlusAvgBandWidthChinaCdn SKUName = "StandardPlus_AvgBandWidth_ChinaCdn"
	SKUNameStandardPlusChinaCdn             SKUName = "StandardPlus_ChinaCdn"
	SKUNameStandardVerizon                  SKUName = "Standard_Verizon"
)

func PossibleSKUNameValues 

func PossibleSKUNameValues() []SKUName

PossibleSKUNameValues returns the possible values for the SKUName const type.

type SSLProtocol 

type SSLProtocol string

SSLProtocol - The protocol of an established TLS connection. 

const (
	SSLProtocolTLSv1  SSLProtocol = "TLSv1"
	SSLProtocolTLSv11 SSLProtocol = "TLSv1.1"
	SSLProtocolTLSv12 SSLProtocol = "TLSv1.2"
)

func PossibleSSLProtocolValues 

func PossibleSSLProtocolValues() []SSLProtocol

PossibleSSLProtocolValues returns the possible values for the SSLProtocol const type.

type SSLProtocolMatchConditionParameters 

type SSLProtocolMatchConditionParameters struct {
	// REQUIRED; Describes operator to be matched
	Operator *SSLProtocolOperator

	// REQUIRED
	TypeName *SSLProtocolMatchConditionParametersTypeName

	// The match value for the condition of the delivery rule
	MatchValues []*SSLProtocol

	// Describes if this is negate condition or not
	NegateCondition *bool

	// List of transforms
	Transforms []*Transform
}

SSLProtocolMatchConditionParameters - Defines the parameters for SslProtocol match conditions

func (SSLProtocolMatchConditionParameters) MarshalJSON 

func (s SSLProtocolMatchConditionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SSLProtocolMatchConditionParameters.

func (*SSLProtocolMatchConditionParameters) UnmarshalJSON 

func (s *SSLProtocolMatchConditionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SSLProtocolMatchConditionParameters.

type SSLProtocolMatchConditionParametersTypeName 

type SSLProtocolMatchConditionParametersTypeName string
const (
	SSLProtocolMatchConditionParametersTypeNameDeliveryRuleSSLProtocolConditionParameters SSLProtocolMatchConditionParametersTypeName = "DeliveryRuleSslProtocolConditionParameters"
)

func PossibleSSLProtocolMatchConditionParametersTypeNameValues 

func PossibleSSLProtocolMatchConditionParametersTypeNameValues() []SSLProtocolMatchConditionParametersTypeName

PossibleSSLProtocolMatchConditionParametersTypeNameValues returns the possible values for the SSLProtocolMatchConditionParametersTypeName const type.

type SSLProtocolOperator 

type SSLProtocolOperator string

SSLProtocolOperator - Describes operator to be matched 

const (
	SSLProtocolOperatorEqual SSLProtocolOperator = "Equal"
)

func PossibleSSLProtocolOperatorValues 

func PossibleSSLProtocolOperatorValues() []SSLProtocolOperator

PossibleSSLProtocolOperatorValues returns the possible values for the SSLProtocolOperator const type.

type ScrubbingRuleEntryMatchOperator added in v2.2.0 

type ScrubbingRuleEntryMatchOperator string

ScrubbingRuleEntryMatchOperator - When matchVariable is a collection, operate on the selector to specify which elements in the collection this rule applies to. 

const (
	ScrubbingRuleEntryMatchOperatorEqualsAny ScrubbingRuleEntryMatchOperator = "EqualsAny"
)

func PossibleScrubbingRuleEntryMatchOperatorValues added in v2.2.0 

func PossibleScrubbingRuleEntryMatchOperatorValues() []ScrubbingRuleEntryMatchOperator

PossibleScrubbingRuleEntryMatchOperatorValues returns the possible values for the ScrubbingRuleEntryMatchOperator const type.

type ScrubbingRuleEntryMatchVariable added in v2.2.0 

type ScrubbingRuleEntryMatchVariable string

ScrubbingRuleEntryMatchVariable - The variable to be scrubbed from the logs. 

const (
	ScrubbingRuleEntryMatchVariableQueryStringArgNames ScrubbingRuleEntryMatchVariable = "QueryStringArgNames"
	ScrubbingRuleEntryMatchVariableRequestIPAddress    ScrubbingRuleEntryMatchVariable = "RequestIPAddress"
	ScrubbingRuleEntryMatchVariableRequestURI          ScrubbingRuleEntryMatchVariable = "RequestUri"
)

func PossibleScrubbingRuleEntryMatchVariableValues added in v2.2.0 

func PossibleScrubbingRuleEntryMatchVariableValues() []ScrubbingRuleEntryMatchVariable

PossibleScrubbingRuleEntryMatchVariableValues returns the possible values for the ScrubbingRuleEntryMatchVariable const type.

type ScrubbingRuleEntryState added in v2.2.0 

type ScrubbingRuleEntryState string

ScrubbingRuleEntryState - Defines the state of a log scrubbing rule. Default value is enabled. 

const (
	ScrubbingRuleEntryStateDisabled ScrubbingRuleEntryState = "Disabled"
	ScrubbingRuleEntryStateEnabled  ScrubbingRuleEntryState = "Enabled"
)

func PossibleScrubbingRuleEntryStateValues added in v2.2.0 

func PossibleScrubbingRuleEntryStateValues() []ScrubbingRuleEntryState

PossibleScrubbingRuleEntryStateValues returns the possible values for the ScrubbingRuleEntryState const type.

type Secret 

type Secret struct {
	// The JSON object that contains the properties of the Secret to create.
	Properties *SecretProperties

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Read only system data
	SystemData *SystemData

	// READ-ONLY; Resource type.
	Type *string
}

Secret - Friendly Secret name mapping to the any Secret or secret related information.

func (Secret) MarshalJSON 

func (s Secret) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Secret.

func (*Secret) UnmarshalJSON 

func (s *Secret) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Secret.

type SecretListResult 

type SecretListResult struct {
	// URL to get the next set of Secret objects if there are any.
	NextLink *string

	// READ-ONLY; List of AzureFrontDoor secrets within a profile.
	Value []*Secret
}

SecretListResult - Result of the request to list secrets. It contains a list of Secret objects and a URL link to get the next set of results.

func (SecretListResult) MarshalJSON 

func (s SecretListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SecretListResult.

func (*SecretListResult) UnmarshalJSON 

func (s *SecretListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SecretListResult.

type SecretParameters 

type SecretParameters struct {
	// REQUIRED; The type of the secret resource.
	Type *SecretType
}

SecretParameters - The json object containing secret parameters

func (*SecretParameters) GetSecretParameters 

func (s *SecretParameters) GetSecretParameters() *SecretParameters

GetSecretParameters implements the SecretParametersClassification interface for type SecretParameters.

func (SecretParameters) MarshalJSON 

func (s SecretParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SecretParameters.

func (*SecretParameters) UnmarshalJSON 

func (s *SecretParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SecretParameters.

type SecretParametersClassification 

type SecretParametersClassification interface {
	// GetSecretParameters returns the SecretParameters content of the underlying type.
	GetSecretParameters() *SecretParameters
}

SecretParametersClassification provides polymorphic access to related types. Call the interface's GetSecretParameters() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *AzureFirstPartyManagedCertificateParameters, *CustomerCertificateParameters, *ManagedCertificateParameters, *SecretParameters, - *URLSigningKeyParameters

type SecretProperties 

type SecretProperties struct {
	// object which contains secret parameters
	Parameters SecretParametersClassification

	// READ-ONLY
	DeploymentStatus *DeploymentStatus

	// READ-ONLY; The name of the profile which holds the secret.
	ProfileName *string

	// READ-ONLY; Provisioning status
	ProvisioningState *AfdProvisioningState
}

SecretProperties - The JSON object that contains the properties of the Secret to create.

func (SecretProperties) MarshalJSON 

func (s SecretProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SecretProperties.

func (*SecretProperties) UnmarshalJSON 

func (s *SecretProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SecretProperties.

type SecretType 

type SecretType string

SecretType - The type of the secret resource. 

const (
	SecretTypeAzureFirstPartyManagedCertificate SecretType = "AzureFirstPartyManagedCertificate"
	SecretTypeCustomerCertificate               SecretType = "CustomerCertificate"
	SecretTypeManagedCertificate                SecretType = "ManagedCertificate"
	SecretTypeURLSigningKey                     SecretType = "UrlSigningKey"
)

func PossibleSecretTypeValues 

func PossibleSecretTypeValues() []SecretType

PossibleSecretTypeValues returns the possible values for the SecretType const type.

type SecretsClient 

type SecretsClient struct {
	// contains filtered or unexported fields
}

SecretsClient contains the methods for the Secrets group. Don't use this type directly, use NewSecretsClient() instead.

func NewSecretsClient 

func NewSecretsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SecretsClient, error)

NewSecretsClient creates a new instance of SecretsClient with the specified values.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*SecretsClient) BeginCreate 

func (client *SecretsClient) BeginCreate(ctx context.Context, resourceGroupName string, profileName string, secretName string, secret Secret, options *SecretsClientBeginCreateOptions) (*runtime.Poller[SecretsClientCreateResponse], error)

BeginCreate - Creates a new Secret within the specified profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • secretName - Name of the Secret under the profile.
  • secret - The Secret properties.
  • options - SecretsClientBeginCreateOptions contains the optional parameters for the SecretsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Secrets_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSecretsClient().BeginCreate(ctx, "RG", "profile1", "secret1", armcdn.Secret{
	Properties: &armcdn.SecretProperties{
		Parameters: &armcdn.CustomerCertificateParameters{
			Type: to.Ptr(armcdn.SecretTypeCustomerCertificate),
			SecretSource: &armcdn.ResourceReference{
				ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.KeyVault/vault/kvName/secrets/certificatename"),
			},
			SecretVersion:    to.Ptr("abcdef1234578900abcdef1234567890"),
			UseLatestVersion: to.Ptr(false),
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Secret = armcdn.Secret{
// 	Name: to.Ptr("secret1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/secrets"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/secrets/secret1"),
// 	Properties: &armcdn.SecretProperties{
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 		Parameters: &armcdn.CustomerCertificateParameters{
// 			Type: to.Ptr(armcdn.SecretTypeCustomerCertificate),
// 			CertificateAuthority: to.Ptr("Symantec"),
// 			ExpirationDate: to.Ptr("2025-01-01T00:00:00-00:00"),
// 			SecretSource: &armcdn.ResourceReference{
// 				ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.KeyVault/vaults/keyvaultname/secrets/certificatename"),
// 			},
// 			SecretVersion: to.Ptr("abcdef1234578900abcdef1234567890"),
// 			Subject: to.Ptr("*.contoso.com"),
// 			SubjectAlternativeNames: []*string{
// 				to.Ptr("foo.contoso.com"),
// 				to.Ptr("www3.foo.contoso.com")},
// 				Thumbprint: to.Ptr("ABCDEF1234567890ABCDEF1234567890ABCDEF12"),
// 				UseLatestVersion: to.Ptr(true),
// 			},
// 		},
// 	}

Output:

func (*SecretsClient) BeginDelete 

func (client *SecretsClient) BeginDelete(ctx context.Context, resourceGroupName string, profileName string, secretName string, options *SecretsClientBeginDeleteOptions) (*runtime.Poller[SecretsClientDeleteResponse], error)

BeginDelete - Deletes an existing Secret within profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • secretName - Name of the Secret under the profile.
  • options - SecretsClientBeginDeleteOptions contains the optional parameters for the SecretsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Secrets_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSecretsClient().BeginDelete(ctx, "RG", "profile1", "secret1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*SecretsClient) Get 

func (client *SecretsClient) Get(ctx context.Context, resourceGroupName string, profileName string, secretName string, options *SecretsClientGetOptions) (SecretsClientGetResponse, error)

Get - Gets an existing Secret within a profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • secretName - Name of the Secret under the profile.
  • options - SecretsClientGetOptions contains the optional parameters for the SecretsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Secrets_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSecretsClient().Get(ctx, "RG", "profile1", "secret1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Secret = armcdn.Secret{
// 	Name: to.Ptr("secret1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/secrets"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/secrets/secret1"),
// 	Properties: &armcdn.SecretProperties{
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 		Parameters: &armcdn.CustomerCertificateParameters{
// 			Type: to.Ptr(armcdn.SecretTypeCustomerCertificate),
// 			CertificateAuthority: to.Ptr("Symantec"),
// 			ExpirationDate: to.Ptr("2025-01-01T00:00:00-00:00"),
// 			SecretSource: &armcdn.ResourceReference{
// 				ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.KeyVault/vaults/keyvaultname/secrets/certificatename"),
// 			},
// 			SecretVersion: to.Ptr("abcdef1234578900abcdef1234567890"),
// 			Subject: to.Ptr("*.contoso.com"),
// 			SubjectAlternativeNames: []*string{
// 				to.Ptr("foo.contoso.com"),
// 				to.Ptr("www3.foo.contoso.com")},
// 				Thumbprint: to.Ptr("ABCDEF1234567890ABCDEF1234567890ABCDEF12"),
// 				UseLatestVersion: to.Ptr(true),
// 			},
// 		},
// 	}

Output:

func (*SecretsClient) NewListByProfilePager 

func (client *SecretsClient) NewListByProfilePager(resourceGroupName string, profileName string, options *SecretsClientListByProfileOptions) *runtime.Pager[SecretsClientListByProfileResponse]

NewListByProfilePager - Lists existing AzureFrontDoor secrets.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • options - SecretsClientListByProfileOptions contains the optional parameters for the SecretsClient.NewListByProfilePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/Secrets_ListByProfile.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewSecretsClient().NewListByProfilePager("RG", "profile1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.SecretListResult = armcdn.SecretListResult{
	// 	Value: []*armcdn.Secret{
	// 		{
	// 			Name: to.Ptr("secret1"),
	// 			Type: to.Ptr("Microsoft.Cdn/profiles/secrets"),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/secrets/secret1"),
	// 			Properties: &armcdn.SecretProperties{
	// 				DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
	// 				ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
	// 				Parameters: &armcdn.CustomerCertificateParameters{
	// 					Type: to.Ptr(armcdn.SecretTypeCustomerCertificate),
	// 					CertificateAuthority: to.Ptr("Symantec"),
	// 					ExpirationDate: to.Ptr("2025-01-01T00:00:00-00:00"),
	// 					SecretSource: &armcdn.ResourceReference{
	// 						ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.KeyVault/vaults/keyvaultname/secrets/certificatename"),
	// 					},
	// 					SecretVersion: to.Ptr("abcdef1234578900abcdef1234567890"),
	// 					Subject: to.Ptr("*.contoso.com"),
	// 					SubjectAlternativeNames: []*string{
	// 						to.Ptr("foo.contoso.com"),
	// 						to.Ptr("www3.foo.contoso.com")},
	// 						Thumbprint: to.Ptr("ABCDEF1234567890ABCDEF1234567890ABCDEF12"),
	// 						UseLatestVersion: to.Ptr(true),
	// 					},
	// 				},
	// 			},
	// 			{
	// 				Name: to.Ptr("69f05517-6aaf-4a1e-a96d-f8c02f66c756-test12-afdx-test-domains-azfdtest-xyz"),
	// 				Type: to.Ptr("Microsoft.Cdn/profiles/secrets"),
	// 				ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/secrets/autogenerated_secret_name"),
	// 				Properties: &armcdn.SecretProperties{
	// 					DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
	// 					ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
	// 					Parameters: &armcdn.ManagedCertificateParameters{
	// 						Type: to.Ptr(armcdn.SecretTypeManagedCertificate),
	// 						ExpirationDate: to.Ptr("2025-01-01T00:00:00-00:00"),
	// 						Subject: to.Ptr("bar.contoso.com"),
	// 					},
	// 				},
	// 		}},
	// 	}
}

Output:

type SecretsClientBeginCreateOptions 

type SecretsClientBeginCreateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

SecretsClientBeginCreateOptions contains the optional parameters for the SecretsClient.BeginCreate method.

type SecretsClientBeginDeleteOptions 

type SecretsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

SecretsClientBeginDeleteOptions contains the optional parameters for the SecretsClient.BeginDelete method.

type SecretsClientCreateResponse 

type SecretsClientCreateResponse struct {
	// Friendly Secret name mapping to the any Secret or secret related information.
	Secret
}

SecretsClientCreateResponse contains the response from method SecretsClient.BeginCreate.

type SecretsClientDeleteResponse 

type SecretsClientDeleteResponse struct {
}

SecretsClientDeleteResponse contains the response from method SecretsClient.BeginDelete.

type SecretsClientGetOptions 

type SecretsClientGetOptions struct {
}

SecretsClientGetOptions contains the optional parameters for the SecretsClient.Get method.

type SecretsClientGetResponse 

type SecretsClientGetResponse struct {
	// Friendly Secret name mapping to the any Secret or secret related information.
	Secret
}

SecretsClientGetResponse contains the response from method SecretsClient.Get.

type SecretsClientListByProfileOptions 

type SecretsClientListByProfileOptions struct {
}

SecretsClientListByProfileOptions contains the optional parameters for the SecretsClient.NewListByProfilePager method.

type SecretsClientListByProfileResponse 

type SecretsClientListByProfileResponse struct {
	// Result of the request to list secrets. It contains a list of Secret objects and a URL link to get the next set of results.
	SecretListResult
}

SecretsClientListByProfileResponse contains the response from method SecretsClient.NewListByProfilePager.

type SecurityPoliciesClient 

type SecurityPoliciesClient struct {
	// contains filtered or unexported fields
}

SecurityPoliciesClient contains the methods for the SecurityPolicies group. Don't use this type directly, use NewSecurityPoliciesClient() instead.

func NewSecurityPoliciesClient 

func NewSecurityPoliciesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SecurityPoliciesClient, error)

NewSecurityPoliciesClient creates a new instance of SecurityPoliciesClient with the specified values.

  • subscriptionID - Azure Subscription ID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*SecurityPoliciesClient) BeginCreate 

func (client *SecurityPoliciesClient) BeginCreate(ctx context.Context, resourceGroupName string, profileName string, securityPolicyName string, securityPolicy SecurityPolicy, options *SecurityPoliciesClientBeginCreateOptions) (*runtime.Poller[SecurityPoliciesClientCreateResponse], error)

BeginCreate - Creates a new security policy within the specified profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • securityPolicyName - Name of the security policy under the profile.
  • securityPolicy - The security policy properties.
  • options - SecurityPoliciesClientBeginCreateOptions contains the optional parameters for the SecurityPoliciesClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/SecurityPolicies_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSecurityPoliciesClient().BeginCreate(ctx, "RG", "profile1", "securityPolicy1", armcdn.SecurityPolicy{
	Properties: &armcdn.SecurityPolicyProperties{
		Parameters: &armcdn.SecurityPolicyWebApplicationFirewallParameters{
			Type: to.Ptr(armcdn.SecurityPolicyTypeWebApplicationFirewall),
			Associations: []*armcdn.SecurityPolicyWebApplicationFirewallAssociation{
				{
					Domains: []*armcdn.ActivatedResourceReference{
						{
							ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/customdomains/testdomain1"),
						},
						{
							ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/customdomains/testdomain2"),
						}},
					PatternsToMatch: []*string{
						to.Ptr("/*")},
				}},
			WafPolicy: &armcdn.ResourceReference{
				ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Network/frontdoorwebapplicationfirewallpolicies/wafTest"),
			},
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.SecurityPolicy = armcdn.SecurityPolicy{
// 	Name: to.Ptr("securityPolicy1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/securitypolicies"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/securitypolicies/securityPolicy1"),
// 	Properties: &armcdn.SecurityPolicyProperties{
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 		Parameters: &armcdn.SecurityPolicyWebApplicationFirewallParameters{
// 			Type: to.Ptr(armcdn.SecurityPolicyTypeWebApplicationFirewall),
// 			Associations: []*armcdn.SecurityPolicyWebApplicationFirewallAssociation{
// 				{
// 					Domains: []*armcdn.ActivatedResourceReference{
// 						{
// 							ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/customdomains/testdomain1"),
// 						},
// 						{
// 							ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/customdomains/testdomain2"),
// 					}},
// 					PatternsToMatch: []*string{
// 						to.Ptr("/*")},
// 				}},
// 				WafPolicy: &armcdn.ResourceReference{
// 					ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Network/frontdoorwebapplicationfirewallpolicies/wafTest"),
// 				},
// 			},
// 		},
// 	}

Output:

func (*SecurityPoliciesClient) BeginDelete 

func (client *SecurityPoliciesClient) BeginDelete(ctx context.Context, resourceGroupName string, profileName string, securityPolicyName string, options *SecurityPoliciesClientBeginDeleteOptions) (*runtime.Poller[SecurityPoliciesClientDeleteResponse], error)

BeginDelete - Deletes an existing security policy within profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • securityPolicyName - Name of the security policy under the profile.
  • options - SecurityPoliciesClientBeginDeleteOptions contains the optional parameters for the SecurityPoliciesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/SecurityPolicies_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSecurityPoliciesClient().BeginDelete(ctx, "RG", "profile1", "securityPolicy1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*SecurityPoliciesClient) BeginPatch 

func (client *SecurityPoliciesClient) BeginPatch(ctx context.Context, resourceGroupName string, profileName string, securityPolicyName string, securityPolicyUpdateProperties SecurityPolicyUpdateParameters, options *SecurityPoliciesClientBeginPatchOptions) (*runtime.Poller[SecurityPoliciesClientPatchResponse], error)

BeginPatch - Updates an existing security policy within a profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • securityPolicyName - Name of the security policy under the profile.
  • securityPolicyUpdateProperties - Security policy update properties
  • options - SecurityPoliciesClientBeginPatchOptions contains the optional parameters for the SecurityPoliciesClient.BeginPatch method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/SecurityPolicies_Patch.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSecurityPoliciesClient().BeginPatch(ctx, "RG", "profile1", "securityPolicy1", armcdn.SecurityPolicyUpdateParameters{
	Properties: &armcdn.SecurityPolicyUpdateProperties{
		Parameters: &armcdn.SecurityPolicyWebApplicationFirewallParameters{
			Type: to.Ptr(armcdn.SecurityPolicyTypeWebApplicationFirewall),
			Associations: []*armcdn.SecurityPolicyWebApplicationFirewallAssociation{
				{
					Domains: []*armcdn.ActivatedResourceReference{
						{
							ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/customdomains/testdomain1"),
						},
						{
							ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/customdomains/testdomain2"),
						}},
					PatternsToMatch: []*string{
						to.Ptr("/*")},
				}},
			WafPolicy: &armcdn.ResourceReference{
				ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Network/frontdoorwebapplicationfirewallpolicies/wafTest"),
			},
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.SecurityPolicy = armcdn.SecurityPolicy{
// 	Name: to.Ptr("securityPolicy1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/securitypolicies"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/securitypolicies/securityPolicy1"),
// 	Properties: &armcdn.SecurityPolicyProperties{
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 		Parameters: &armcdn.SecurityPolicyWebApplicationFirewallParameters{
// 			Type: to.Ptr(armcdn.SecurityPolicyTypeWebApplicationFirewall),
// 			Associations: []*armcdn.SecurityPolicyWebApplicationFirewallAssociation{
// 				{
// 					Domains: []*armcdn.ActivatedResourceReference{
// 						{
// 							ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/customdomains/testdomain1"),
// 						},
// 						{
// 							ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/customdomains/testdomain2"),
// 					}},
// 					PatternsToMatch: []*string{
// 						to.Ptr("/*")},
// 				}},
// 				WafPolicy: &armcdn.ResourceReference{
// 					ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Network/frontdoorwebapplicationfirewallpolicies/wafTest"),
// 				},
// 			},
// 		},
// 	}

Output:

func (*SecurityPoliciesClient) Get 

func (client *SecurityPoliciesClient) Get(ctx context.Context, resourceGroupName string, profileName string, securityPolicyName string, options *SecurityPoliciesClientGetOptions) (SecurityPoliciesClientGetResponse, error)

Get - Gets an existing security policy within a profile. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • securityPolicyName - Name of the security policy under the profile.
  • options - SecurityPoliciesClientGetOptions contains the optional parameters for the SecurityPoliciesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/SecurityPolicies_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSecurityPoliciesClient().Get(ctx, "RG", "profile1", "securityPolicy1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.SecurityPolicy = armcdn.SecurityPolicy{
// 	Name: to.Ptr("securityPolicy1"),
// 	Type: to.Ptr("Microsoft.Cdn/profiles/securitypolicies"),
// 	ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/securitypolicies/securityPolicy1"),
// 	Properties: &armcdn.SecurityPolicyProperties{
// 		DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
// 		ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
// 		Parameters: &armcdn.SecurityPolicyWebApplicationFirewallParameters{
// 			Type: to.Ptr(armcdn.SecurityPolicyTypeWebApplicationFirewall),
// 			Associations: []*armcdn.SecurityPolicyWebApplicationFirewallAssociation{
// 				{
// 					Domains: []*armcdn.ActivatedResourceReference{
// 						{
// 							ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/customdomains/testdomain1"),
// 						},
// 						{
// 							ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/customdomains/testdomain2"),
// 					}},
// 					PatternsToMatch: []*string{
// 						to.Ptr("/*")},
// 				}},
// 				WafPolicy: &armcdn.ResourceReference{
// 					ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Network/frontdoorwebapplicationfirewallpolicies/wafTest"),
// 				},
// 			},
// 		},
// 	}

Output:

func (*SecurityPoliciesClient) NewListByProfilePager 

func (client *SecurityPoliciesClient) NewListByProfilePager(resourceGroupName string, profileName string, options *SecurityPoliciesClientListByProfileOptions) *runtime.Pager[SecurityPoliciesClientListByProfileResponse]

NewListByProfilePager - Lists security policies associated with the profile

Generated from API version 2024-02-01

  • resourceGroupName - Name of the Resource group within the Azure subscription.
  • profileName - Name of the Azure Front Door Standard or Azure Front Door Premium profile which is unique within the resource group.
  • options - SecurityPoliciesClientListByProfileOptions contains the optional parameters for the SecurityPoliciesClient.NewListByProfilePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/cdn/resource-manager/Microsoft.Cdn/stable/2024-02-01/examples/SecurityPolicies_ListByProfile.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcdn.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewSecurityPoliciesClient().NewListByProfilePager("RG", "profile1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.SecurityPolicyListResult = armcdn.SecurityPolicyListResult{
	// 	Value: []*armcdn.SecurityPolicy{
	// 		{
	// 			Name: to.Ptr("securityPolicy1"),
	// 			Type: to.Ptr("Microsoft.Cdn/profiles/securitypolicies"),
	// 			ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/securitypolicies/securityPolicy1"),
	// 			Properties: &armcdn.SecurityPolicyProperties{
	// 				DeploymentStatus: to.Ptr(armcdn.DeploymentStatusNotStarted),
	// 				ProvisioningState: to.Ptr(armcdn.AfdProvisioningStateSucceeded),
	// 				Parameters: &armcdn.SecurityPolicyWebApplicationFirewallParameters{
	// 					Type: to.Ptr(armcdn.SecurityPolicyTypeWebApplicationFirewall),
	// 					Associations: []*armcdn.SecurityPolicyWebApplicationFirewallAssociation{
	// 						{
	// 							Domains: []*armcdn.ActivatedResourceReference{
	// 								{
	// 									ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/customdomains/testdomain1"),
	// 								},
	// 								{
	// 									ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Cdn/profiles/profile1/customdomains/testdomain2"),
	// 							}},
	// 							PatternsToMatch: []*string{
	// 								to.Ptr("/*")},
	// 						}},
	// 						WafPolicy: &armcdn.ResourceReference{
	// 							ID: to.Ptr("/subscriptions/subid/resourcegroups/RG/providers/Microsoft.Network/frontdoorwebapplicationfirewallpolicies/wafTest"),
	// 						},
	// 					},
	// 				},
	// 		}},
	// 	}
}

Output:

type SecurityPoliciesClientBeginCreateOptions 

type SecurityPoliciesClientBeginCreateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

SecurityPoliciesClientBeginCreateOptions contains the optional parameters for the SecurityPoliciesClient.BeginCreate method.

type SecurityPoliciesClientBeginDeleteOptions 

type SecurityPoliciesClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

SecurityPoliciesClientBeginDeleteOptions contains the optional parameters for the SecurityPoliciesClient.BeginDelete method.

type SecurityPoliciesClientBeginPatchOptions 

type SecurityPoliciesClientBeginPatchOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

SecurityPoliciesClientBeginPatchOptions contains the optional parameters for the SecurityPoliciesClient.BeginPatch method.

type SecurityPoliciesClientCreateResponse 

type SecurityPoliciesClientCreateResponse struct {
	// SecurityPolicy association for AzureFrontDoor profile
	SecurityPolicy
}

SecurityPoliciesClientCreateResponse contains the response from method SecurityPoliciesClient.BeginCreate.

type SecurityPoliciesClientDeleteResponse 

type SecurityPoliciesClientDeleteResponse struct {
}

SecurityPoliciesClientDeleteResponse contains the response from method SecurityPoliciesClient.BeginDelete.

type SecurityPoliciesClientGetOptions 

type SecurityPoliciesClientGetOptions struct {
}

SecurityPoliciesClientGetOptions contains the optional parameters for the SecurityPoliciesClient.Get method.

type SecurityPoliciesClientGetResponse 

type SecurityPoliciesClientGetResponse struct {
	// SecurityPolicy association for AzureFrontDoor profile
	SecurityPolicy
}

SecurityPoliciesClientGetResponse contains the response from method SecurityPoliciesClient.Get.

type SecurityPoliciesClientListByProfileOptions 

type SecurityPoliciesClientListByProfileOptions struct {
}

SecurityPoliciesClientListByProfileOptions contains the optional parameters for the SecurityPoliciesClient.NewListByProfilePager method.

type SecurityPoliciesClientListByProfileResponse 

type SecurityPoliciesClientListByProfileResponse struct {
	// Result of the request to list security policies. It contains a list of security policy objects and a URL link to get the
	// next set of results.
	SecurityPolicyListResult
}

SecurityPoliciesClientListByProfileResponse contains the response from method SecurityPoliciesClient.NewListByProfilePager.

type SecurityPoliciesClientPatchResponse 

type SecurityPoliciesClientPatchResponse struct {
	// SecurityPolicy association for AzureFrontDoor profile
	SecurityPolicy
}

SecurityPoliciesClientPatchResponse contains the response from method SecurityPoliciesClient.BeginPatch.

type SecurityPolicy 

type SecurityPolicy struct {
	// The json object that contains properties required to create a security policy
	Properties *SecurityPolicyProperties

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Read only system data
	SystemData *SystemData

	// READ-ONLY; Resource type.
	Type *string
}

SecurityPolicy association for AzureFrontDoor profile

func (SecurityPolicy) MarshalJSON 

func (s SecurityPolicy) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SecurityPolicy.

func (*SecurityPolicy) UnmarshalJSON 

func (s *SecurityPolicy) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SecurityPolicy.

type SecurityPolicyListResult 

type SecurityPolicyListResult struct {
	// URL to get the next set of security policy objects if there is any.
	NextLink *string

	// READ-ONLY; List of Security policies within a profile
	Value []*SecurityPolicy
}

SecurityPolicyListResult - Result of the request to list security policies. It contains a list of security policy objects and a URL link to get the next set of results.

func (SecurityPolicyListResult) MarshalJSON 

func (s SecurityPolicyListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SecurityPolicyListResult.

func (*SecurityPolicyListResult) UnmarshalJSON 

func (s *SecurityPolicyListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SecurityPolicyListResult.

type SecurityPolicyProperties 

type SecurityPolicyProperties struct {
	// object which contains security policy parameters
	Parameters SecurityPolicyPropertiesParametersClassification

	// READ-ONLY
	DeploymentStatus *DeploymentStatus

	// READ-ONLY; The name of the profile which holds the security policy.
	ProfileName *string

	// READ-ONLY; Provisioning status
	ProvisioningState *AfdProvisioningState
}

SecurityPolicyProperties - The json object that contains properties required to create a security policy

func (SecurityPolicyProperties) MarshalJSON 

func (s SecurityPolicyProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SecurityPolicyProperties.

func (*SecurityPolicyProperties) UnmarshalJSON 

func (s *SecurityPolicyProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SecurityPolicyProperties.

type SecurityPolicyPropertiesParameters 

type SecurityPolicyPropertiesParameters struct {
	// REQUIRED; The type of the Security policy to create.
	Type *SecurityPolicyType
}

SecurityPolicyPropertiesParameters - The json object containing security policy parameters

func (*SecurityPolicyPropertiesParameters) GetSecurityPolicyPropertiesParameters 

func (s *SecurityPolicyPropertiesParameters) GetSecurityPolicyPropertiesParameters() *SecurityPolicyPropertiesParameters

GetSecurityPolicyPropertiesParameters implements the SecurityPolicyPropertiesParametersClassification interface for type SecurityPolicyPropertiesParameters.

func (SecurityPolicyPropertiesParameters) MarshalJSON 

func (s SecurityPolicyPropertiesParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SecurityPolicyPropertiesParameters.

func (*SecurityPolicyPropertiesParameters) UnmarshalJSON 

func (s *SecurityPolicyPropertiesParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SecurityPolicyPropertiesParameters.

type SecurityPolicyPropertiesParametersClassification 

type SecurityPolicyPropertiesParametersClassification interface {
	// GetSecurityPolicyPropertiesParameters returns the SecurityPolicyPropertiesParameters content of the underlying type.
	GetSecurityPolicyPropertiesParameters() *SecurityPolicyPropertiesParameters
}

SecurityPolicyPropertiesParametersClassification provides polymorphic access to related types. Call the interface's GetSecurityPolicyPropertiesParameters() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *SecurityPolicyPropertiesParameters, *SecurityPolicyWebApplicationFirewallParameters

type SecurityPolicyType 

type SecurityPolicyType string

SecurityPolicyType - The type of the Security policy to create. 

const (
	SecurityPolicyTypeWebApplicationFirewall SecurityPolicyType = "WebApplicationFirewall"
)

func PossibleSecurityPolicyTypeValues 

func PossibleSecurityPolicyTypeValues() []SecurityPolicyType

PossibleSecurityPolicyTypeValues returns the possible values for the SecurityPolicyType const type.

type SecurityPolicyUpdateParameters 

type SecurityPolicyUpdateParameters struct {
	// The json object that contains properties required to update a security policy
	Properties *SecurityPolicyUpdateProperties
}

SecurityPolicyUpdateParameters - The JSON object containing security policy update parameters.

func (SecurityPolicyUpdateParameters) MarshalJSON 

func (s SecurityPolicyUpdateParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SecurityPolicyUpdateParameters.

func (*SecurityPolicyUpdateParameters) UnmarshalJSON 

func (s *SecurityPolicyUpdateParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SecurityPolicyUpdateParameters.

type SecurityPolicyUpdateProperties 

type SecurityPolicyUpdateProperties struct {
	// object which contains security policy parameters
	Parameters SecurityPolicyPropertiesParametersClassification
}

SecurityPolicyUpdateProperties - The json object that contains properties required to update a security policy

func (SecurityPolicyUpdateProperties) MarshalJSON 

func (s SecurityPolicyUpdateProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SecurityPolicyUpdateProperties.

func (*SecurityPolicyUpdateProperties) UnmarshalJSON 

func (s *SecurityPolicyUpdateProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SecurityPolicyUpdateProperties.

type SecurityPolicyWebApplicationFirewallAssociation 

type SecurityPolicyWebApplicationFirewallAssociation struct {
	// List of domains.
	Domains []*ActivatedResourceReference

	// List of paths
	PatternsToMatch []*string
}

SecurityPolicyWebApplicationFirewallAssociation - settings for security policy patterns to match

func (SecurityPolicyWebApplicationFirewallAssociation) MarshalJSON 

func (s SecurityPolicyWebApplicationFirewallAssociation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SecurityPolicyWebApplicationFirewallAssociation.

func (*SecurityPolicyWebApplicationFirewallAssociation) UnmarshalJSON 

func (s *SecurityPolicyWebApplicationFirewallAssociation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SecurityPolicyWebApplicationFirewallAssociation.

type SecurityPolicyWebApplicationFirewallParameters 

type SecurityPolicyWebApplicationFirewallParameters struct {
	// REQUIRED; The type of the Security policy to create.
	Type *SecurityPolicyType

	// Waf associations
	Associations []*SecurityPolicyWebApplicationFirewallAssociation

	// Resource ID.
	WafPolicy *ResourceReference
}

SecurityPolicyWebApplicationFirewallParameters - The json object containing security policy waf parameters

func (*SecurityPolicyWebApplicationFirewallParameters) GetSecurityPolicyPropertiesParameters 

func (s *SecurityPolicyWebApplicationFirewallParameters) GetSecurityPolicyPropertiesParameters() *SecurityPolicyPropertiesParameters

GetSecurityPolicyPropertiesParameters implements the SecurityPolicyPropertiesParametersClassification interface for type SecurityPolicyWebApplicationFirewallParameters.

func (SecurityPolicyWebApplicationFirewallParameters) MarshalJSON 

func (s SecurityPolicyWebApplicationFirewallParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SecurityPolicyWebApplicationFirewallParameters.

func (*SecurityPolicyWebApplicationFirewallParameters) UnmarshalJSON 

func (s *SecurityPolicyWebApplicationFirewallParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SecurityPolicyWebApplicationFirewallParameters.

type ServerPortMatchConditionParameters 

type ServerPortMatchConditionParameters struct {
	// REQUIRED; Describes operator to be matched
	Operator *ServerPortOperator

	// REQUIRED
	TypeName *ServerPortMatchConditionParametersTypeName

	// The match value for the condition of the delivery rule
	MatchValues []*string

	// Describes if this is negate condition or not
	NegateCondition *bool

	// List of transforms
	Transforms []*Transform
}

ServerPortMatchConditionParameters - Defines the parameters for ServerPort match conditions

func (ServerPortMatchConditionParameters) MarshalJSON 

func (s ServerPortMatchConditionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ServerPortMatchConditionParameters.

func (*ServerPortMatchConditionParameters) UnmarshalJSON 

func (s *ServerPortMatchConditionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ServerPortMatchConditionParameters.

type ServerPortMatchConditionParametersTypeName 

type ServerPortMatchConditionParametersTypeName string
const (
	ServerPortMatchConditionParametersTypeNameDeliveryRuleServerPortConditionParameters ServerPortMatchConditionParametersTypeName = "DeliveryRuleServerPortConditionParameters"
)

func PossibleServerPortMatchConditionParametersTypeNameValues 

func PossibleServerPortMatchConditionParametersTypeNameValues() []ServerPortMatchConditionParametersTypeName

PossibleServerPortMatchConditionParametersTypeNameValues returns the possible values for the ServerPortMatchConditionParametersTypeName const type.

type ServerPortOperator 

type ServerPortOperator string

ServerPortOperator - Describes operator to be matched 

const (
	ServerPortOperatorAny                ServerPortOperator = "Any"
	ServerPortOperatorBeginsWith         ServerPortOperator = "BeginsWith"
	ServerPortOperatorContains           ServerPortOperator = "Contains"
	ServerPortOperatorEndsWith           ServerPortOperator = "EndsWith"
	ServerPortOperatorEqual              ServerPortOperator = "Equal"
	ServerPortOperatorGreaterThan        ServerPortOperator = "GreaterThan"
	ServerPortOperatorGreaterThanOrEqual ServerPortOperator = "GreaterThanOrEqual"
	ServerPortOperatorLessThan           ServerPortOperator = "LessThan"
	ServerPortOperatorLessThanOrEqual    ServerPortOperator = "LessThanOrEqual"
	ServerPortOperatorRegEx              ServerPortOperator = "RegEx"
)

func PossibleServerPortOperatorValues 

func PossibleServerPortOperatorValues() []ServerPortOperator

PossibleServerPortOperatorValues returns the possible values for the ServerPortOperator const type.

type ServiceSpecification 

type ServiceSpecification struct {
	// Log specifications of operation.
	LogSpecifications []*LogSpecification

	// Metric specifications of operation.
	MetricSpecifications []*MetricSpecification
}

ServiceSpecification - One property of operation, include log specifications.

func (ServiceSpecification) MarshalJSON 

func (s ServiceSpecification) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ServiceSpecification.

func (*ServiceSpecification) UnmarshalJSON 

func (s *ServiceSpecification) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceSpecification.

type SharedPrivateLinkResourceProperties 

type SharedPrivateLinkResourceProperties struct {
	// The group id from the provider of resource the shared private link resource is for.
	GroupID *string

	// The resource id of the resource the shared private link resource is for.
	PrivateLink *ResourceReference

	// The location of the shared private link resource
	PrivateLinkLocation *string

	// The request message for requesting approval of the shared private link resource.
	RequestMessage *string

	// Status of the shared private link resource. Can be Pending, Approved, Rejected, Disconnected, or Timeout.
	Status *SharedPrivateLinkResourceStatus
}

SharedPrivateLinkResourceProperties - Describes the properties of an existing Shared Private Link Resource to use when connecting to a private origin.

func (SharedPrivateLinkResourceProperties) MarshalJSON 

func (s SharedPrivateLinkResourceProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SharedPrivateLinkResourceProperties.

func (*SharedPrivateLinkResourceProperties) UnmarshalJSON 

func (s *SharedPrivateLinkResourceProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SharedPrivateLinkResourceProperties.

type SharedPrivateLinkResourceStatus 

type SharedPrivateLinkResourceStatus string

SharedPrivateLinkResourceStatus - Status of the shared private link resource. Can be Pending, Approved, Rejected, Disconnected, or Timeout. 

const (
	SharedPrivateLinkResourceStatusApproved     SharedPrivateLinkResourceStatus = "Approved"
	SharedPrivateLinkResourceStatusDisconnected SharedPrivateLinkResourceStatus = "Disconnected"
	SharedPrivateLinkResourceStatusPending      SharedPrivateLinkResourceStatus = "Pending"
	SharedPrivateLinkResourceStatusRejected     SharedPrivateLinkResourceStatus = "Rejected"
	SharedPrivateLinkResourceStatusTimeout      SharedPrivateLinkResourceStatus = "Timeout"
)

func PossibleSharedPrivateLinkResourceStatusValues 

func PossibleSharedPrivateLinkResourceStatusValues() []SharedPrivateLinkResourceStatus

PossibleSharedPrivateLinkResourceStatusValues returns the possible values for the SharedPrivateLinkResourceStatus const type.

type SocketAddrMatchConditionParameters 

type SocketAddrMatchConditionParameters struct {
	// REQUIRED; Describes operator to be matched
	Operator *SocketAddrOperator

	// REQUIRED
	TypeName *SocketAddrMatchConditionParametersTypeName

	// The match value for the condition of the delivery rule
	MatchValues []*string

	// Describes if this is negate condition or not
	NegateCondition *bool

	// List of transforms
	Transforms []*Transform
}

SocketAddrMatchConditionParameters - Defines the parameters for SocketAddress match conditions

func (SocketAddrMatchConditionParameters) MarshalJSON 

func (s SocketAddrMatchConditionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SocketAddrMatchConditionParameters.

func (*SocketAddrMatchConditionParameters) UnmarshalJSON 

func (s *SocketAddrMatchConditionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SocketAddrMatchConditionParameters.

type SocketAddrMatchConditionParametersTypeName 

type SocketAddrMatchConditionParametersTypeName string
const (
	SocketAddrMatchConditionParametersTypeNameDeliveryRuleSocketAddrConditionParameters SocketAddrMatchConditionParametersTypeName = "DeliveryRuleSocketAddrConditionParameters"
)

func PossibleSocketAddrMatchConditionParametersTypeNameValues 

func PossibleSocketAddrMatchConditionParametersTypeNameValues() []SocketAddrMatchConditionParametersTypeName

PossibleSocketAddrMatchConditionParametersTypeNameValues returns the possible values for the SocketAddrMatchConditionParametersTypeName const type.

type SocketAddrOperator 

type SocketAddrOperator string

SocketAddrOperator - Describes operator to be matched 

const (
	SocketAddrOperatorAny     SocketAddrOperator = "Any"
	SocketAddrOperatorIPMatch SocketAddrOperator = "IPMatch"
)

func PossibleSocketAddrOperatorValues 

func PossibleSocketAddrOperatorValues() []SocketAddrOperator

PossibleSocketAddrOperatorValues returns the possible values for the SocketAddrOperator const type.

type SsoURI 

type SsoURI struct {
	// READ-ONLY; The URI used to login to the supplemental portal.
	SsoURIValue *string
}

SsoURI - The URI required to login to the supplemental portal from the Azure portal.

func (SsoURI) MarshalJSON 

func (s SsoURI) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SsoURI.

func (*SsoURI) UnmarshalJSON 

func (s *SsoURI) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SsoURI.

type Status 

type Status string

Status - The validation status. 

const (
	StatusAccessDenied       Status = "AccessDenied"
	StatusCertificateExpired Status = "CertificateExpired"
	StatusInvalid            Status = "Invalid"
	StatusValid              Status = "Valid"
)

func PossibleStatusValues 

func PossibleStatusValues() []Status

PossibleStatusValues returns the possible values for the Status const type.

type SupportedOptimizationTypesListResult 

type SupportedOptimizationTypesListResult struct {
	// READ-ONLY; Supported optimization types for a profile.
	SupportedOptimizationTypes []*OptimizationType
}

SupportedOptimizationTypesListResult - The result of the GetSupportedOptimizationTypes API

func (SupportedOptimizationTypesListResult) MarshalJSON 

func (s SupportedOptimizationTypesListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SupportedOptimizationTypesListResult.

func (*SupportedOptimizationTypesListResult) UnmarshalJSON 

func (s *SupportedOptimizationTypesListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SupportedOptimizationTypesListResult.

type SystemData 

type SystemData struct {
	// The timestamp of resource creation (UTC)
	CreatedAt *time.Time

	// An identifier for the identity that created the resource
	CreatedBy *string

	// The type of identity that created the resource
	CreatedByType *IdentityType

	// The timestamp of resource last modification (UTC)
	LastModifiedAt *time.Time

	// An identifier for the identity that last modified the resource
	LastModifiedBy *string

	// The type of identity that last modified the resource
	LastModifiedByType *IdentityType
}

SystemData - Read only system data

func (SystemData) MarshalJSON 

func (s SystemData) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON 

func (s *SystemData) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

type Transform 

type Transform string

Transform - Describes what transforms are applied before matching 

const (
	TransformLowercase   Transform = "Lowercase"
	TransformRemoveNulls Transform = "RemoveNulls"
	TransformTrim        Transform = "Trim"
	TransformURLDecode   Transform = "UrlDecode"
	TransformURLEncode   Transform = "UrlEncode"
	TransformUppercase   Transform = "Uppercase"
)

func PossibleTransformValues 

func PossibleTransformValues() []Transform

PossibleTransformValues returns the possible values for the Transform const type.

type TransformType 

type TransformType string

TransformType - Describes what transforms were applied before matching. 

const (
	TransformTypeLowercase   TransformType = "Lowercase"
	TransformTypeRemoveNulls TransformType = "RemoveNulls"
	TransformTypeTrim        TransformType = "Trim"
	TransformTypeURLDecode   TransformType = "UrlDecode"
	TransformTypeURLEncode   TransformType = "UrlEncode"
	TransformTypeUppercase   TransformType = "Uppercase"
)

func PossibleTransformTypeValues 

func PossibleTransformTypeValues() []TransformType

PossibleTransformTypeValues returns the possible values for the TransformType const type.

type URLFileExtensionMatchConditionParameters 

type URLFileExtensionMatchConditionParameters struct {
	// REQUIRED; Describes operator to be matched
	Operator *URLFileExtensionOperator

	// REQUIRED
	TypeName *URLFileExtensionMatchConditionParametersTypeName

	// The match value for the condition of the delivery rule
	MatchValues []*string

	// Describes if this is negate condition or not
	NegateCondition *bool

	// List of transforms
	Transforms []*Transform
}

URLFileExtensionMatchConditionParameters - Defines the parameters for UrlFileExtension match conditions

func (URLFileExtensionMatchConditionParameters) MarshalJSON 

func (u URLFileExtensionMatchConditionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type URLFileExtensionMatchConditionParameters.

func (*URLFileExtensionMatchConditionParameters) UnmarshalJSON 

func (u *URLFileExtensionMatchConditionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type URLFileExtensionMatchConditionParameters.

type URLFileExtensionMatchConditionParametersTypeName 

type URLFileExtensionMatchConditionParametersTypeName string
const (
	URLFileExtensionMatchConditionParametersTypeNameDeliveryRuleURLFileExtensionMatchConditionParameters URLFileExtensionMatchConditionParametersTypeName = "DeliveryRuleUrlFileExtensionMatchConditionParameters"
)

func PossibleURLFileExtensionMatchConditionParametersTypeNameValues 

func PossibleURLFileExtensionMatchConditionParametersTypeNameValues() []URLFileExtensionMatchConditionParametersTypeName

PossibleURLFileExtensionMatchConditionParametersTypeNameValues returns the possible values for the URLFileExtensionMatchConditionParametersTypeName const type.

type URLFileExtensionOperator 

type URLFileExtensionOperator string

URLFileExtensionOperator - Describes operator to be matched 

const (
	URLFileExtensionOperatorAny                URLFileExtensionOperator = "Any"
	URLFileExtensionOperatorBeginsWith         URLFileExtensionOperator = "BeginsWith"
	URLFileExtensionOperatorContains           URLFileExtensionOperator = "Contains"
	URLFileExtensionOperatorEndsWith           URLFileExtensionOperator = "EndsWith"
	URLFileExtensionOperatorEqual              URLFileExtensionOperator = "Equal"
	URLFileExtensionOperatorGreaterThan        URLFileExtensionOperator = "GreaterThan"
	URLFileExtensionOperatorGreaterThanOrEqual URLFileExtensionOperator = "GreaterThanOrEqual"
	URLFileExtensionOperatorLessThan           URLFileExtensionOperator = "LessThan"
	URLFileExtensionOperatorLessThanOrEqual    URLFileExtensionOperator = "LessThanOrEqual"
	URLFileExtensionOperatorRegEx              URLFileExtensionOperator = "RegEx"
)

func PossibleURLFileExtensionOperatorValues 

func PossibleURLFileExtensionOperatorValues() []URLFileExtensionOperator

PossibleURLFileExtensionOperatorValues returns the possible values for the URLFileExtensionOperator const type.

type URLFileNameMatchConditionParameters 

type URLFileNameMatchConditionParameters struct {
	// REQUIRED; Describes operator to be matched
	Operator *URLFileNameOperator

	// REQUIRED
	TypeName *URLFileNameMatchConditionParametersTypeName

	// The match value for the condition of the delivery rule
	MatchValues []*string

	// Describes if this is negate condition or not
	NegateCondition *bool

	// List of transforms
	Transforms []*Transform
}

URLFileNameMatchConditionParameters - Defines the parameters for UrlFilename match conditions

func (URLFileNameMatchConditionParameters) MarshalJSON 

func (u URLFileNameMatchConditionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type URLFileNameMatchConditionParameters.

func (*URLFileNameMatchConditionParameters) UnmarshalJSON 

func (u *URLFileNameMatchConditionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type URLFileNameMatchConditionParameters.

type URLFileNameMatchConditionParametersTypeName 

type URLFileNameMatchConditionParametersTypeName string
const (
	URLFileNameMatchConditionParametersTypeNameDeliveryRuleURLFilenameConditionParameters URLFileNameMatchConditionParametersTypeName = "DeliveryRuleUrlFilenameConditionParameters"
)

func PossibleURLFileNameMatchConditionParametersTypeNameValues 

func PossibleURLFileNameMatchConditionParametersTypeNameValues() []URLFileNameMatchConditionParametersTypeName

PossibleURLFileNameMatchConditionParametersTypeNameValues returns the possible values for the URLFileNameMatchConditionParametersTypeName const type.

type URLFileNameOperator 

type URLFileNameOperator string

URLFileNameOperator - Describes operator to be matched 

const (
	URLFileNameOperatorAny                URLFileNameOperator = "Any"
	URLFileNameOperatorBeginsWith         URLFileNameOperator = "BeginsWith"
	URLFileNameOperatorContains           URLFileNameOperator = "Contains"
	URLFileNameOperatorEndsWith           URLFileNameOperator = "EndsWith"
	URLFileNameOperatorEqual              URLFileNameOperator = "Equal"
	URLFileNameOperatorGreaterThan        URLFileNameOperator = "GreaterThan"
	URLFileNameOperatorGreaterThanOrEqual URLFileNameOperator = "GreaterThanOrEqual"
	URLFileNameOperatorLessThan           URLFileNameOperator = "LessThan"
	URLFileNameOperatorLessThanOrEqual    URLFileNameOperator = "LessThanOrEqual"
	URLFileNameOperatorRegEx              URLFileNameOperator = "RegEx"
)

func PossibleURLFileNameOperatorValues 

func PossibleURLFileNameOperatorValues() []URLFileNameOperator

PossibleURLFileNameOperatorValues returns the possible values for the URLFileNameOperator const type.

type URLPathMatchConditionParameters 

type URLPathMatchConditionParameters struct {
	// REQUIRED; Describes operator to be matched
	Operator *URLPathOperator

	// REQUIRED
	TypeName *URLPathMatchConditionParametersTypeName

	// The match value for the condition of the delivery rule
	MatchValues []*string

	// Describes if this is negate condition or not
	NegateCondition *bool

	// List of transforms
	Transforms []*Transform
}

URLPathMatchConditionParameters - Defines the parameters for UrlPath match conditions

func (URLPathMatchConditionParameters) MarshalJSON 

func (u URLPathMatchConditionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type URLPathMatchConditionParameters.

func (*URLPathMatchConditionParameters) UnmarshalJSON 

func (u *URLPathMatchConditionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type URLPathMatchConditionParameters.

type URLPathMatchConditionParametersTypeName 

type URLPathMatchConditionParametersTypeName string
const (
	URLPathMatchConditionParametersTypeNameDeliveryRuleURLPathMatchConditionParameters URLPathMatchConditionParametersTypeName = "DeliveryRuleUrlPathMatchConditionParameters"
)

func PossibleURLPathMatchConditionParametersTypeNameValues 

func PossibleURLPathMatchConditionParametersTypeNameValues() []URLPathMatchConditionParametersTypeName

PossibleURLPathMatchConditionParametersTypeNameValues returns the possible values for the URLPathMatchConditionParametersTypeName const type.

type URLPathOperator 

type URLPathOperator string

URLPathOperator - Describes operator to be matched 

const (
	URLPathOperatorAny                URLPathOperator = "Any"
	URLPathOperatorBeginsWith         URLPathOperator = "BeginsWith"
	URLPathOperatorContains           URLPathOperator = "Contains"
	URLPathOperatorEndsWith           URLPathOperator = "EndsWith"
	URLPathOperatorEqual              URLPathOperator = "Equal"
	URLPathOperatorGreaterThan        URLPathOperator = "GreaterThan"
	URLPathOperatorGreaterThanOrEqual URLPathOperator = "GreaterThanOrEqual"
	URLPathOperatorLessThan           URLPathOperator = "LessThan"
	URLPathOperatorLessThanOrEqual    URLPathOperator = "LessThanOrEqual"
	URLPathOperatorRegEx              URLPathOperator = "RegEx"
	URLPathOperatorWildcard           URLPathOperator = "Wildcard"
)

func PossibleURLPathOperatorValues 

func PossibleURLPathOperatorValues() []URLPathOperator

PossibleURLPathOperatorValues returns the possible values for the URLPathOperator const type.

type URLRedirectAction 

type URLRedirectAction struct {
	// REQUIRED; The name of the action for the delivery rule.
	Name *DeliveryRuleAction

	// REQUIRED; Defines the parameters for the action.
	Parameters *URLRedirectActionParameters
}

URLRedirectAction - Defines the url redirect action for the delivery rule.

func (*URLRedirectAction) GetDeliveryRuleActionAutoGenerated 

func (u *URLRedirectAction) GetDeliveryRuleActionAutoGenerated() *DeliveryRuleActionAutoGenerated

GetDeliveryRuleActionAutoGenerated implements the DeliveryRuleActionAutoGeneratedClassification interface for type URLRedirectAction.

func (URLRedirectAction) MarshalJSON 

func (u URLRedirectAction) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type URLRedirectAction.

func (*URLRedirectAction) UnmarshalJSON 

func (u *URLRedirectAction) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type URLRedirectAction.

type URLRedirectActionParameters 

type URLRedirectActionParameters struct {
	// REQUIRED; The redirect type the rule will use when redirecting traffic.
	RedirectType *RedirectType

	// REQUIRED
	TypeName *URLRedirectActionParametersTypeName

	// Fragment to add to the redirect URL. Fragment is the part of the URL that comes after #. Do not include the #.
	CustomFragment *string

	// Host to redirect. Leave empty to use the incoming host as the destination host.
	CustomHostname *string

	// The full path to redirect. Path cannot be empty and must start with /. Leave empty to use the incoming path as destination
	// path.
	CustomPath *string

	// The set of query strings to be placed in the redirect URL. Setting this value would replace any existing query string;
	// leave empty to preserve the incoming query string. Query string must be in =
	// format. ? and & will be added automatically so do not include them.
	CustomQueryString *string

	// Protocol to use for the redirect. The default value is MatchRequest
	DestinationProtocol *DestinationProtocol
}

URLRedirectActionParameters - Defines the parameters for the url redirect action.

func (URLRedirectActionParameters) MarshalJSON 

func (u URLRedirectActionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type URLRedirectActionParameters.

func (*URLRedirectActionParameters) UnmarshalJSON 

func (u *URLRedirectActionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type URLRedirectActionParameters.

type URLRedirectActionParametersTypeName 

type URLRedirectActionParametersTypeName string
const (
	URLRedirectActionParametersTypeNameDeliveryRuleURLRedirectActionParameters URLRedirectActionParametersTypeName = "DeliveryRuleUrlRedirectActionParameters"
)

func PossibleURLRedirectActionParametersTypeNameValues 

func PossibleURLRedirectActionParametersTypeNameValues() []URLRedirectActionParametersTypeName

PossibleURLRedirectActionParametersTypeNameValues returns the possible values for the URLRedirectActionParametersTypeName const type.

type URLRewriteAction 

type URLRewriteAction struct {
	// REQUIRED; The name of the action for the delivery rule.
	Name *DeliveryRuleAction

	// REQUIRED; Defines the parameters for the action.
	Parameters *URLRewriteActionParameters
}

URLRewriteAction - Defines the url rewrite action for the delivery rule.

func (*URLRewriteAction) GetDeliveryRuleActionAutoGenerated 

func (u *URLRewriteAction) GetDeliveryRuleActionAutoGenerated() *DeliveryRuleActionAutoGenerated

GetDeliveryRuleActionAutoGenerated implements the DeliveryRuleActionAutoGeneratedClassification interface for type URLRewriteAction.

func (URLRewriteAction) MarshalJSON 

func (u URLRewriteAction) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type URLRewriteAction.

func (*URLRewriteAction) UnmarshalJSON 

func (u *URLRewriteAction) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type URLRewriteAction.

type URLRewriteActionParameters 

type URLRewriteActionParameters struct {
	// REQUIRED; Define the relative URL to which the above requests will be rewritten by.
	Destination *string

	// REQUIRED; define a request URI pattern that identifies the type of requests that may be rewritten. If value is blank, all
	// strings are matched.
	SourcePattern *string

	// REQUIRED
	TypeName *URLRewriteActionParametersTypeName

	// Whether to preserve unmatched path. Default value is true.
	PreserveUnmatchedPath *bool
}

URLRewriteActionParameters - Defines the parameters for the url rewrite action.

func (URLRewriteActionParameters) MarshalJSON 

func (u URLRewriteActionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type URLRewriteActionParameters.

func (*URLRewriteActionParameters) UnmarshalJSON 

func (u *URLRewriteActionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type URLRewriteActionParameters.

type URLRewriteActionParametersTypeName 

type URLRewriteActionParametersTypeName string
const (
	URLRewriteActionParametersTypeNameDeliveryRuleURLRewriteActionParameters URLRewriteActionParametersTypeName = "DeliveryRuleUrlRewriteActionParameters"
)

func PossibleURLRewriteActionParametersTypeNameValues 

func PossibleURLRewriteActionParametersTypeNameValues() []URLRewriteActionParametersTypeName

PossibleURLRewriteActionParametersTypeNameValues returns the possible values for the URLRewriteActionParametersTypeName const type.

type URLSigningAction 

type URLSigningAction struct {
	// REQUIRED; The name of the action for the delivery rule.
	Name *DeliveryRuleAction

	// REQUIRED; Defines the parameters for the action.
	Parameters *URLSigningActionParameters
}

URLSigningAction - Defines the url signing action for the delivery rule.

func (*URLSigningAction) GetDeliveryRuleActionAutoGenerated 

func (u *URLSigningAction) GetDeliveryRuleActionAutoGenerated() *DeliveryRuleActionAutoGenerated

GetDeliveryRuleActionAutoGenerated implements the DeliveryRuleActionAutoGeneratedClassification interface for type URLSigningAction.

func (URLSigningAction) MarshalJSON 

func (u URLSigningAction) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type URLSigningAction.

func (*URLSigningAction) UnmarshalJSON 

func (u *URLSigningAction) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type URLSigningAction.

type URLSigningActionParameters 

type URLSigningActionParameters struct {
	// REQUIRED
	TypeName *URLSigningActionParametersTypeName

	// Algorithm to use for URL signing
	Algorithm *Algorithm

	// Defines which query string parameters in the url to be considered for expires, key id etc.
	ParameterNameOverride []*URLSigningParamIdentifier
}

URLSigningActionParameters - Defines the parameters for the Url Signing action.

func (URLSigningActionParameters) MarshalJSON 

func (u URLSigningActionParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type URLSigningActionParameters.

func (*URLSigningActionParameters) UnmarshalJSON 

func (u *URLSigningActionParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type URLSigningActionParameters.

type URLSigningActionParametersTypeName 

type URLSigningActionParametersTypeName string
const (
	URLSigningActionParametersTypeNameDeliveryRuleURLSigningActionParameters URLSigningActionParametersTypeName = "DeliveryRuleUrlSigningActionParameters"
)

func PossibleURLSigningActionParametersTypeNameValues 

func PossibleURLSigningActionParametersTypeNameValues() []URLSigningActionParametersTypeName

PossibleURLSigningActionParametersTypeNameValues returns the possible values for the URLSigningActionParametersTypeName const type.

type URLSigningKey 

type URLSigningKey struct {
	// REQUIRED; Defines the customer defined key Id. This id will exist in the incoming request to indicate the key used to form
	// the hash.
	KeyID *string

	// REQUIRED; Defines the parameters for using customer key vault for Url Signing Key.
	KeySourceParameters *KeyVaultSigningKeyParameters
}

URLSigningKey - Url signing key

func (URLSigningKey) MarshalJSON 

func (u URLSigningKey) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type URLSigningKey.

func (*URLSigningKey) UnmarshalJSON 

func (u *URLSigningKey) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type URLSigningKey.

type URLSigningKeyParameters 

type URLSigningKeyParameters struct {
	// REQUIRED; Defines the customer defined key Id. This id will exist in the incoming request to indicate the key used to form
	// the hash.
	KeyID *string

	// REQUIRED; Resource reference to the Azure Key Vault secret. Expected to be in format of
	// /subscriptions/{​​​​​​​​​subscriptionId}​​​​​​​​​/resourceGroups/{​​​​​​​​​resourceGroupName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​/providers/Microsoft.KeyVault/vaults/{vaultName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​/secrets/{secretName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​
	SecretSource *ResourceReference

	// REQUIRED; The type of the secret resource.
	Type *SecretType

	// Version of the secret to be used
	SecretVersion *string
}

URLSigningKeyParameters - Url signing key parameters

func (*URLSigningKeyParameters) GetSecretParameters 

func (u *URLSigningKeyParameters) GetSecretParameters() *SecretParameters

GetSecretParameters implements the SecretParametersClassification interface for type URLSigningKeyParameters.

func (URLSigningKeyParameters) MarshalJSON 

func (u URLSigningKeyParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type URLSigningKeyParameters.

func (*URLSigningKeyParameters) UnmarshalJSON 

func (u *URLSigningKeyParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type URLSigningKeyParameters.

type URLSigningParamIdentifier 

type URLSigningParamIdentifier struct {
	// REQUIRED; Indicates the purpose of the parameter
	ParamIndicator *ParamIndicator

	// REQUIRED; Parameter name
	ParamName *string
}

URLSigningParamIdentifier - Defines how to identify a parameter for a specific purpose e.g. expires

func (URLSigningParamIdentifier) MarshalJSON 

func (u URLSigningParamIdentifier) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type URLSigningParamIdentifier.

func (*URLSigningParamIdentifier) UnmarshalJSON 

func (u *URLSigningParamIdentifier) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type URLSigningParamIdentifier.

type UpdateRule 

type UpdateRule string

UpdateRule - Describes the action that shall be taken when the certificate is updated in Key Vault. 

const (
	UpdateRuleNoAction UpdateRule = "NoAction"
)

func PossibleUpdateRuleValues 

func PossibleUpdateRuleValues() []UpdateRule

PossibleUpdateRuleValues returns the possible values for the UpdateRule const type.

type Usage 

type Usage struct {
	// REQUIRED; The current value of the usage.
	CurrentValue *int64

	// REQUIRED; The limit of usage.
	Limit *int64

	// REQUIRED; The name of the type of usage.
	Name *UsageName

	// REQUIRED; An enum describing the unit of measurement.
	Unit *UsageUnit

	// READ-ONLY; Resource identifier.
	ID *string
}

Usage - Describes resource usage.

func (Usage) MarshalJSON 

func (u Usage) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Usage.

func (*Usage) UnmarshalJSON 

func (u *Usage) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Usage.

type UsageName 

type UsageName struct {
	// A localized string describing the resource name.
	LocalizedValue *string

	// A string describing the resource name.
	Value *string
}

UsageName - The usage names.

func (UsageName) MarshalJSON 

func (u UsageName) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UsageName.

func (*UsageName) UnmarshalJSON 

func (u *UsageName) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UsageName.

type UsageUnit 

type UsageUnit string

UsageUnit - An enum describing the unit of measurement. 

const (
	UsageUnitCount UsageUnit = "Count"
)

func PossibleUsageUnitValues 

func PossibleUsageUnitValues() []UsageUnit

PossibleUsageUnitValues returns the possible values for the UsageUnit const type.

type UsagesListResult 

type UsagesListResult struct {
	// URL to get the next set of results.
	NextLink *string

	// The list of resource usages.
	Value []*Usage
}

UsagesListResult - The list usages operation response.

func (UsagesListResult) MarshalJSON 

func (u UsagesListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UsagesListResult.

func (*UsagesListResult) UnmarshalJSON 

func (u *UsagesListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UsagesListResult.

type UserAssignedIdentity 

type UserAssignedIdentity struct {
	// READ-ONLY; The client ID of the assigned identity.
	ClientID *string

	// READ-ONLY; The principal ID of the assigned identity.
	PrincipalID *string
}

UserAssignedIdentity - User assigned identity properties

func (UserAssignedIdentity) MarshalJSON 

func (u UserAssignedIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UserAssignedIdentity.

func (*UserAssignedIdentity) UnmarshalJSON 

func (u *UserAssignedIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UserAssignedIdentity.

type UserManagedHTTPSParameters 

type UserManagedHTTPSParameters struct {
	// REQUIRED; Defines the source of the SSL certificate.
	CertificateSource *CertificateSource

	// REQUIRED; Defines the certificate source parameters using user's keyvault certificate for enabling SSL.
	CertificateSourceParameters *KeyVaultCertificateSourceParameters

	// REQUIRED; Defines the TLS extension protocol that is used for secure delivery.
	ProtocolType *ProtocolType

	// TLS protocol version that will be used for Https
	MinimumTLSVersion *MinimumTLSVersion
}

UserManagedHTTPSParameters - Defines the certificate source parameters using user's keyvault certificate for enabling SSL.

func (*UserManagedHTTPSParameters) GetCustomDomainHTTPSParameters 

func (u *UserManagedHTTPSParameters) GetCustomDomainHTTPSParameters() *CustomDomainHTTPSParameters

GetCustomDomainHTTPSParameters implements the CustomDomainHTTPSParametersClassification interface for type UserManagedHTTPSParameters.

func (UserManagedHTTPSParameters) MarshalJSON 

func (u UserManagedHTTPSParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UserManagedHTTPSParameters.

func (*UserManagedHTTPSParameters) UnmarshalJSON 

func (u *UserManagedHTTPSParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UserManagedHTTPSParameters.

type ValidateCustomDomainInput 

type ValidateCustomDomainInput struct {
	// REQUIRED; The host name of the custom domain. Must be a domain name.
	HostName *string
}

ValidateCustomDomainInput - Input of the custom domain to be validated for DNS mapping.

func (ValidateCustomDomainInput) MarshalJSON 

func (v ValidateCustomDomainInput) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ValidateCustomDomainInput.

func (*ValidateCustomDomainInput) UnmarshalJSON 

func (v *ValidateCustomDomainInput) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ValidateCustomDomainInput.

type ValidateCustomDomainOutput 

type ValidateCustomDomainOutput struct {
	// READ-ONLY; Indicates whether the custom domain is valid or not.
	CustomDomainValidated *bool

	// READ-ONLY; Error message describing why the custom domain is not valid.
	Message *string

	// READ-ONLY; The reason why the custom domain is not valid.
	Reason *string
}

ValidateCustomDomainOutput - Output of custom domain validation.

func (ValidateCustomDomainOutput) MarshalJSON 

func (v ValidateCustomDomainOutput) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ValidateCustomDomainOutput.

func (*ValidateCustomDomainOutput) UnmarshalJSON 

func (v *ValidateCustomDomainOutput) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ValidateCustomDomainOutput.

type ValidateProbeInput 

type ValidateProbeInput struct {
	// REQUIRED; The probe URL to validate.
	ProbeURL *string
}

ValidateProbeInput - Input of the validate probe API.

func (ValidateProbeInput) MarshalJSON 

func (v ValidateProbeInput) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ValidateProbeInput.

func (*ValidateProbeInput) UnmarshalJSON 

func (v *ValidateProbeInput) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ValidateProbeInput.

type ValidateProbeOutput 

type ValidateProbeOutput struct {
	// READ-ONLY; Specifies the error code when the probe url is not accepted.
	ErrorCode *string

	// READ-ONLY; Indicates whether the probe URL is accepted or not.
	IsValid *bool

	// READ-ONLY; The detailed error message describing why the probe URL is not accepted.
	Message *string
}

ValidateProbeOutput - Output of the validate probe API.

func (ValidateProbeOutput) MarshalJSON 

func (v ValidateProbeOutput) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ValidateProbeOutput.

func (*ValidateProbeOutput) UnmarshalJSON 

func (v *ValidateProbeOutput) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ValidateProbeOutput.

type ValidateSecretInput 

type ValidateSecretInput struct {
	// REQUIRED; Resource reference to the Azure Key Vault secret. Expected to be in format of
	// /subscriptions/{​​​​​​​​​subscriptionId}​​​​​​​​​/resourceGroups/{​​​​​​​​​resourceGroupName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​/providers/Microsoft.KeyVault/vaults/{vaultName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​/secrets/{secretName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​
	SecretSource *ResourceReference

	// REQUIRED; The secret type.
	SecretType *SecretType

	// Secret version, if customer is using a specific version.
	SecretVersion *string
}

ValidateSecretInput - Input of the secret to be validated.

func (ValidateSecretInput) MarshalJSON 

func (v ValidateSecretInput) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ValidateSecretInput.

func (*ValidateSecretInput) UnmarshalJSON 

func (v *ValidateSecretInput) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ValidateSecretInput.

type ValidateSecretOutput 

type ValidateSecretOutput struct {
	// Detailed error message
	Message *string

	// The validation status.
	Status *Status
}

ValidateSecretOutput - Output of the validated secret.

func (ValidateSecretOutput) MarshalJSON 

func (v ValidateSecretOutput) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ValidateSecretOutput.

func (*ValidateSecretOutput) UnmarshalJSON 

func (v *ValidateSecretOutput) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ValidateSecretOutput.

type WafAction 

type WafAction string
const (
	WafActionAllow    WafAction = "allow"
	WafActionBlock    WafAction = "block"
	WafActionLog      WafAction = "log"
	WafActionRedirect WafAction = "redirect"
)

func PossibleWafActionValues 

func PossibleWafActionValues() []WafAction

PossibleWafActionValues returns the possible values for the WafAction const type.

type WafGranularity 

type WafGranularity string
const (
	WafGranularityP1D  WafGranularity = "P1D"
	WafGranularityPT1H WafGranularity = "PT1H"
	WafGranularityPT5M WafGranularity = "PT5M"
)

func PossibleWafGranularityValues 

func PossibleWafGranularityValues() []WafGranularity

PossibleWafGranularityValues returns the possible values for the WafGranularity const type.

type WafMatchVariable 

type WafMatchVariable string

WafMatchVariable - Match variable to compare against. 

const (
	WafMatchVariableCookies       WafMatchVariable = "Cookies"
	WafMatchVariablePostArgs      WafMatchVariable = "PostArgs"
	WafMatchVariableQueryString   WafMatchVariable = "QueryString"
	WafMatchVariableRemoteAddr    WafMatchVariable = "RemoteAddr"
	WafMatchVariableRequestBody   WafMatchVariable = "RequestBody"
	WafMatchVariableRequestHeader WafMatchVariable = "RequestHeader"
	WafMatchVariableRequestMethod WafMatchVariable = "RequestMethod"
	WafMatchVariableRequestURI    WafMatchVariable = "RequestUri"
	WafMatchVariableSocketAddr    WafMatchVariable = "SocketAddr"
)

func PossibleWafMatchVariableValues 

func PossibleWafMatchVariableValues() []WafMatchVariable

PossibleWafMatchVariableValues returns the possible values for the WafMatchVariable const type.

type WafMetric 

type WafMetric string
const (
	WafMetricClientRequestCount WafMetric = "clientRequestCount"
)

func PossibleWafMetricValues 

func PossibleWafMetricValues() []WafMetric

PossibleWafMetricValues returns the possible values for the WafMetric const type.

type WafMetricsGranularity 

type WafMetricsGranularity string
const (
	WafMetricsGranularityP1D  WafMetricsGranularity = "P1D"
	WafMetricsGranularityPT1H WafMetricsGranularity = "PT1H"
	WafMetricsGranularityPT5M WafMetricsGranularity = "PT5M"
)

func PossibleWafMetricsGranularityValues 

func PossibleWafMetricsGranularityValues() []WafMetricsGranularity

PossibleWafMetricsGranularityValues returns the possible values for the WafMetricsGranularity const type.

type WafMetricsResponse 

type WafMetricsResponse struct {
	DateTimeBegin *time.Time
	DateTimeEnd   *time.Time
	Granularity   *WafMetricsGranularity
	Series        []*WafMetricsResponseSeriesItem
}

WafMetricsResponse - Waf Metrics Response

func (WafMetricsResponse) MarshalJSON 

func (w WafMetricsResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WafMetricsResponse.

func (*WafMetricsResponse) UnmarshalJSON 

func (w *WafMetricsResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WafMetricsResponse.

type WafMetricsResponseSeriesItem 

type WafMetricsResponseSeriesItem struct {
	Data   []*Components18OrqelSchemasWafmetricsresponsePropertiesSeriesItemsPropertiesDataItems
	Groups []*WafMetricsResponseSeriesPropertiesItemsItem
	Metric *string
	Unit   *WafMetricsSeriesUnit
}

func (WafMetricsResponseSeriesItem) MarshalJSON 

func (w WafMetricsResponseSeriesItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WafMetricsResponseSeriesItem.

func (*WafMetricsResponseSeriesItem) UnmarshalJSON 

func (w *WafMetricsResponseSeriesItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WafMetricsResponseSeriesItem.

type WafMetricsResponseSeriesPropertiesItemsItem 

type WafMetricsResponseSeriesPropertiesItemsItem struct {
	Name  *string
	Value *string
}

func (WafMetricsResponseSeriesPropertiesItemsItem) MarshalJSON 

func (w WafMetricsResponseSeriesPropertiesItemsItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WafMetricsResponseSeriesPropertiesItemsItem.

func (*WafMetricsResponseSeriesPropertiesItemsItem) UnmarshalJSON 

func (w *WafMetricsResponseSeriesPropertiesItemsItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WafMetricsResponseSeriesPropertiesItemsItem.

type WafMetricsSeriesUnit 

type WafMetricsSeriesUnit string
const (
	WafMetricsSeriesUnitCount WafMetricsSeriesUnit = "count"
)

func PossibleWafMetricsSeriesUnitValues 

func PossibleWafMetricsSeriesUnitValues() []WafMetricsSeriesUnit

PossibleWafMetricsSeriesUnitValues returns the possible values for the WafMetricsSeriesUnit const type.

type WafRankingGroupBy 

type WafRankingGroupBy string
const (
	WafRankingGroupByCustomDomain   WafRankingGroupBy = "customDomain"
	WafRankingGroupByHTTPStatusCode WafRankingGroupBy = "httpStatusCode"
)

func PossibleWafRankingGroupByValues 

func PossibleWafRankingGroupByValues() []WafRankingGroupBy

PossibleWafRankingGroupByValues returns the possible values for the WafRankingGroupBy const type.

type WafRankingType 

type WafRankingType string
const (
	WafRankingTypeAction          WafRankingType = "action"
	WafRankingTypeClientIP        WafRankingType = "clientIp"
	WafRankingTypeCountryOrRegion WafRankingType = "countryOrRegion"
	WafRankingTypeRuleGroup       WafRankingType = "ruleGroup"
	WafRankingTypeRuleID          WafRankingType = "ruleId"
	WafRankingTypeRuleType        WafRankingType = "ruleType"
	WafRankingTypeURL             WafRankingType = "url"
	WafRankingTypeUserAgent       WafRankingType = "userAgent"
)

func PossibleWafRankingTypeValues 

func PossibleWafRankingTypeValues() []WafRankingType

PossibleWafRankingTypeValues returns the possible values for the WafRankingType const type.

type WafRankingsResponse 

type WafRankingsResponse struct {
	Data          []*WafRankingsResponseDataItem
	DateTimeBegin *time.Time
	DateTimeEnd   *time.Time
	Groups        []*string
}

WafRankingsResponse - Waf Rankings Response

func (WafRankingsResponse) MarshalJSON 

func (w WafRankingsResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WafRankingsResponse.

func (*WafRankingsResponse) UnmarshalJSON 

func (w *WafRankingsResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WafRankingsResponse.

type WafRankingsResponseDataItem 

type WafRankingsResponseDataItem struct {
	GroupValues []*string
	Metrics     []*ComponentsKpo1PjSchemasWafrankingsresponsePropertiesDataItemsPropertiesMetricsItems
}

func (WafRankingsResponseDataItem) MarshalJSON 

func (w WafRankingsResponseDataItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WafRankingsResponseDataItem.

func (*WafRankingsResponseDataItem) UnmarshalJSON 

func (w *WafRankingsResponseDataItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WafRankingsResponseDataItem.

type WafRuleType 

type WafRuleType string
const (
	WafRuleTypeBot     WafRuleType = "bot"
	WafRuleTypeCustom  WafRuleType = "custom"
	WafRuleTypeManaged WafRuleType = "managed"
)

func PossibleWafRuleTypeValues 

func PossibleWafRuleTypeValues() []WafRuleType

PossibleWafRuleTypeValues returns the possible values for the WafRuleType const type.

type WebApplicationFirewallPolicy 

type WebApplicationFirewallPolicy struct {
	// REQUIRED; Resource location.
	Location *string

	// REQUIRED; The pricing tier (defines a CDN provider, feature list and rate) of the CdnWebApplicationFirewallPolicy.
	SKU *SKU

	// Gets a unique read-only string that changes whenever the resource is updated.
	Etag *string

	// Properties of the web application firewall policy.
	Properties *WebApplicationFirewallPolicyProperties

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Read only system data
	SystemData *SystemData

	// READ-ONLY; Resource type.
	Type *string
}

WebApplicationFirewallPolicy - Defines web application firewall policy for Azure CDN.

func (WebApplicationFirewallPolicy) MarshalJSON 

func (w WebApplicationFirewallPolicy) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WebApplicationFirewallPolicy.

func (*WebApplicationFirewallPolicy) UnmarshalJSON 

func (w *WebApplicationFirewallPolicy) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WebApplicationFirewallPolicy.

type WebApplicationFirewallPolicyList 

type WebApplicationFirewallPolicyList struct {
	// URL to get the next set of WebApplicationFirewallPolicy objects if there are any.
	NextLink *string

	// READ-ONLY; List of Azure CDN WebApplicationFirewallPolicies within a resource group.
	Value []*WebApplicationFirewallPolicy
}

WebApplicationFirewallPolicyList - Defines a list of WebApplicationFirewallPolicies for Azure CDN. It contains a list of WebApplicationFirewallPolicy objects and a URL link to get the next set of results.

func (WebApplicationFirewallPolicyList) MarshalJSON 

func (w WebApplicationFirewallPolicyList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WebApplicationFirewallPolicyList.

func (*WebApplicationFirewallPolicyList) UnmarshalJSON 

func (w *WebApplicationFirewallPolicyList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WebApplicationFirewallPolicyList.

type WebApplicationFirewallPolicyPatchParameters 

type WebApplicationFirewallPolicyPatchParameters struct {
	// CdnWebApplicationFirewallPolicy tags
	Tags map[string]*string
}

WebApplicationFirewallPolicyPatchParameters - Properties required to update a CdnWebApplicationFirewallPolicy.

func (WebApplicationFirewallPolicyPatchParameters) MarshalJSON 

func (w WebApplicationFirewallPolicyPatchParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WebApplicationFirewallPolicyPatchParameters.

func (*WebApplicationFirewallPolicyPatchParameters) UnmarshalJSON 

func (w *WebApplicationFirewallPolicyPatchParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WebApplicationFirewallPolicyPatchParameters.

type WebApplicationFirewallPolicyProperties 

type WebApplicationFirewallPolicyProperties struct {
	// Describes custom rules inside the policy.
	CustomRules *CustomRuleList

	// Key-Value pair representing additional properties for Web Application Firewall policy.
	ExtendedProperties map[string]*string

	// Describes managed rules inside the policy.
	ManagedRules *ManagedRuleSetList

	// Describes policySettings for policy
	PolicySettings *PolicySettings

	// Describes rate limit rules inside the policy.
	RateLimitRules *RateLimitRuleList

	// READ-ONLY; Describes Azure CDN endpoints associated with this Web Application Firewall policy.
	EndpointLinks []*LinkedEndpoint

	// READ-ONLY; Provisioning state of the WebApplicationFirewallPolicy.
	ProvisioningState *ProvisioningState

	// READ-ONLY; Resource status of the policy.
	ResourceState *PolicyResourceState
}

WebApplicationFirewallPolicyProperties - Defines CDN web application firewall policy properties.

func (WebApplicationFirewallPolicyProperties) MarshalJSON 

func (w WebApplicationFirewallPolicyProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WebApplicationFirewallPolicyProperties.

func (*WebApplicationFirewallPolicyProperties) UnmarshalJSON 

func (w *WebApplicationFirewallPolicyProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WebApplicationFirewallPolicyProperties.

Source Files

View all Source files

Directories

Path Synopsis

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.