armnginx

package module
v3.0.0 Latest Latest
Warning

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

 Go to latest Published: Nov 23, 2023 License: MIT Imports: 14 Imported by: 0

README

Azure Nginx Module for Go

PkgGoDev

The armnginx module provides operations for working with Azure Nginx.

Source code

Getting started

Prerequisites

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure Nginx module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/nginx/armnginx/v2

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Nginx. 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 Nginx 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 := armnginx.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 := armnginx.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.NewDeploymentsClient()

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 Nginx 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 Certificate 

type Certificate struct {
	Location   *string
	Properties *CertificateProperties

	// READ-ONLY
	ID *string

	// READ-ONLY
	Name *string

	// READ-ONLY; Metadata pertaining to creation and last modification of the resource.
	SystemData *SystemData

	// READ-ONLY
	Type *string
}

func (Certificate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Certificate.

func (*Certificate) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Certificate.

type CertificateListResponse 

type CertificateListResponse struct {
	NextLink *string
	Value    []*Certificate
}

func (CertificateListResponse) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CertificateListResponse.

func (*CertificateListResponse) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CertificateListResponse.

type CertificateProperties 

type CertificateProperties struct {
	CertificateVirtualPath *string
	KeyVaultSecretID       *string
	KeyVirtualPath         *string

	// READ-ONLY
	ProvisioningState *ProvisioningState
}

func (CertificateProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CertificateProperties.

func (*CertificateProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CertificateProperties.

type CertificatesClient 

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

CertificatesClient contains the methods for the Certificates group. Don't use this type directly, use NewCertificatesClient() instead.

func NewCertificatesClient 

func NewCertificatesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*CertificatesClient, error)

NewCertificatesClient creates a new instance of CertificatesClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*CertificatesClient) BeginCreateOrUpdate 

func (client *CertificatesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, deploymentName string, certificateName string, options *CertificatesClientBeginCreateOrUpdateOptions) (*runtime.Poller[CertificatesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create or update the NGINX certificates for given NGINX deployment If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deploymentName - The name of targeted NGINX deployment
  • certificateName - The name of certificate
  • options - CertificatesClientBeginCreateOrUpdateOptions contains the optional parameters for the CertificatesClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/nginx/resource-manager/NGINX.NGINXPLUS/stable/2023-04-01/examples/Certificates_CreateOrUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnginx.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewCertificatesClient().BeginCreateOrUpdate(ctx, "myResourceGroup", "myDeployment", "default", &armnginx.CertificatesClientBeginCreateOrUpdateOptions{Body: 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.Certificate = armnginx.Certificate{
// 	Name: to.Ptr("default"),
// 	Type: to.Ptr("nginx.nginxplus/nginxdeployments/certificates"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/NGINX.NGINXPLUS/nginxDeployments/myDeployment/certificates/default"),
// 	Properties: &armnginx.CertificateProperties{
// 		CertificateVirtualPath: to.Ptr("/src/cert/somePath.cert"),
// 		KeyVaultSecretID: to.Ptr("https://someKV.vault.azure.com/someSecretID"),
// 		KeyVirtualPath: to.Ptr("/src/cert/somekey.key"),
// 		ProvisioningState: to.Ptr(armnginx.ProvisioningStateSucceeded),
// 	},
// }

Output:

func (*CertificatesClient) BeginDelete 

func (client *CertificatesClient) BeginDelete(ctx context.Context, resourceGroupName string, deploymentName string, certificateName string, options *CertificatesClientBeginDeleteOptions) (*runtime.Poller[CertificatesClientDeleteResponse], error)

BeginDelete - Deletes a certificate from the NGINX deployment If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deploymentName - The name of targeted NGINX deployment
  • certificateName - The name of certificate
  • options - CertificatesClientBeginDeleteOptions contains the optional parameters for the CertificatesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/nginx/resource-manager/NGINX.NGINXPLUS/stable/2023-04-01/examples/Certificates_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnginx.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewCertificatesClient().BeginDelete(ctx, "myResourceGroup", "myDeployment", "default", 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 (*CertificatesClient) Get 

func (client *CertificatesClient) Get(ctx context.Context, resourceGroupName string, deploymentName string, certificateName string, options *CertificatesClientGetOptions) (CertificatesClientGetResponse, error)

Get - Get a certificate of given NGINX deployment If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deploymentName - The name of targeted NGINX deployment
  • certificateName - The name of certificate
  • options - CertificatesClientGetOptions contains the optional parameters for the CertificatesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/nginx/resource-manager/NGINX.NGINXPLUS/stable/2023-04-01/examples/Certificates_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnginx.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewCertificatesClient().Get(ctx, "myResourceGroup", "myDeployment", "default", 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.Certificate = armnginx.Certificate{
// 	Name: to.Ptr("default"),
// 	Type: to.Ptr("nginx.nginxplus/nginxdeployments/certificates"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/NGINX.NGINXPLUS/nginxDeployments/myDeployment/certificates/default"),
// 	Properties: &armnginx.CertificateProperties{
// 		CertificateVirtualPath: to.Ptr("/src/cert/somePath.cert"),
// 		KeyVaultSecretID: to.Ptr("https://someKV.vault.azure.com/someSecretID"),
// 		KeyVirtualPath: to.Ptr("/src/cert/somekey.key"),
// 		ProvisioningState: to.Ptr(armnginx.ProvisioningStateSucceeded),
// 	},
// }

Output:

func (*CertificatesClient) NewListPager 

func (client *CertificatesClient) NewListPager(resourceGroupName string, deploymentName string, options *CertificatesClientListOptions) *runtime.Pager[CertificatesClientListResponse]

NewListPager - List all certificates of given NGINX deployment

Generated from API version 2023-04-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deploymentName - The name of targeted NGINX deployment
  • options - CertificatesClientListOptions contains the optional parameters for the CertificatesClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/nginx/resource-manager/NGINX.NGINXPLUS/stable/2023-04-01/examples/Certificates_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnginx.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewCertificatesClient().NewListPager("myResourceGroup", "myDeployment", 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.CertificateListResponse = armnginx.CertificateListResponse{
	// 	Value: []*armnginx.Certificate{
	// 		{
	// 			Name: to.Ptr("cert1"),
	// 			Type: to.Ptr("nginx.nginxplus/nginxdeployments/certificates"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/NGINX.NGINXPLUS/nginxDeployments/myDeployment/certificates/cert1"),
	// 			Properties: &armnginx.CertificateProperties{
	// 				CertificateVirtualPath: to.Ptr("/src/cert/somePath.cert"),
	// 				KeyVaultSecretID: to.Ptr("https://someKV.vault.azure.com/someSecretID"),
	// 				KeyVirtualPath: to.Ptr("/src/cert/somekey.key"),
	// 				ProvisioningState: to.Ptr(armnginx.ProvisioningStateSucceeded),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("cert2"),
	// 			Type: to.Ptr("nginx.nginxplus/nginxdeployments/certificates"),
	// 			ID: to.Ptr("/subscritions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/NGINX.NGINXPLUS/nginxDeployments/myDeployment/certificates/cert2"),
	// 			Properties: &armnginx.CertificateProperties{
	// 				CertificateVirtualPath: to.Ptr("/src/cert/somePath2.cert"),
	// 				KeyVaultSecretID: to.Ptr("https://someKV.vault.azure.com/someSecretID2"),
	// 				KeyVirtualPath: to.Ptr("/src/cert/somekey2.key"),
	// 				ProvisioningState: to.Ptr(armnginx.ProvisioningStateSucceeded),
	// 			},
	// 	}},
	// }
}

Output:

type CertificatesClientBeginCreateOrUpdateOptions 

type CertificatesClientBeginCreateOrUpdateOptions struct {
	// The certificate
	Body *Certificate

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

CertificatesClientBeginCreateOrUpdateOptions contains the optional parameters for the CertificatesClient.BeginCreateOrUpdate method.

type CertificatesClientBeginDeleteOptions 

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

CertificatesClientBeginDeleteOptions contains the optional parameters for the CertificatesClient.BeginDelete method.

type CertificatesClientCreateOrUpdateResponse 

type CertificatesClientCreateOrUpdateResponse struct {
	Certificate
}

CertificatesClientCreateOrUpdateResponse contains the response from method CertificatesClient.BeginCreateOrUpdate.

type CertificatesClientDeleteResponse 

type CertificatesClientDeleteResponse struct {
}

CertificatesClientDeleteResponse contains the response from method CertificatesClient.BeginDelete.

type CertificatesClientGetOptions 

type CertificatesClientGetOptions struct {
}

CertificatesClientGetOptions contains the optional parameters for the CertificatesClient.Get method.

type CertificatesClientGetResponse 

type CertificatesClientGetResponse struct {
	Certificate
}

CertificatesClientGetResponse contains the response from method CertificatesClient.Get.

type CertificatesClientListOptions 

type CertificatesClientListOptions struct {
}

CertificatesClientListOptions contains the optional parameters for the CertificatesClient.NewListPager method.

type CertificatesClientListResponse 

type CertificatesClientListResponse struct {
	CertificateListResponse
}

CertificatesClientListResponse contains the response from method CertificatesClient.NewListPager.

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 - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewCertificatesClient 

func (c *ClientFactory) NewCertificatesClient() *CertificatesClient

NewCertificatesClient creates a new instance of CertificatesClient.

func (*ClientFactory) NewConfigurationsClient 

func (c *ClientFactory) NewConfigurationsClient() *ConfigurationsClient

NewConfigurationsClient creates a new instance of ConfigurationsClient.

func (*ClientFactory) NewDeploymentsClient 

func (c *ClientFactory) NewDeploymentsClient() *DeploymentsClient

NewDeploymentsClient creates a new instance of DeploymentsClient.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

type Configuration 

type Configuration struct {
	Location   *string
	Properties *ConfigurationProperties

	// READ-ONLY
	ID *string

	// READ-ONLY
	Name *string

	// READ-ONLY; Metadata pertaining to creation and last modification of the resource.
	SystemData *SystemData

	// READ-ONLY
	Type *string
}

func (Configuration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Configuration.

func (*Configuration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Configuration.

type ConfigurationFile 

type ConfigurationFile struct {
	Content     *string
	VirtualPath *string
}

func (ConfigurationFile) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ConfigurationFile.

func (*ConfigurationFile) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigurationFile.

type ConfigurationListResponse 

type ConfigurationListResponse struct {
	// Link to the next set of results, if any.
	NextLink *string

	// Results of a list operation.
	Value []*Configuration
}

ConfigurationListResponse - Response of a list operation.

func (ConfigurationListResponse) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ConfigurationListResponse.

func (*ConfigurationListResponse) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigurationListResponse.

type ConfigurationPackage 

type ConfigurationPackage struct {
	Data           *string
	ProtectedFiles []*string
}

func (ConfigurationPackage) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ConfigurationPackage.

func (*ConfigurationPackage) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigurationPackage.

type ConfigurationProperties 

type ConfigurationProperties struct {
	Files          []*ConfigurationFile
	Package        *ConfigurationPackage
	ProtectedFiles []*ConfigurationFile
	RootFile       *string

	// READ-ONLY
	ProvisioningState *ProvisioningState
}

func (ConfigurationProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ConfigurationProperties.

func (*ConfigurationProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigurationProperties.

type ConfigurationsClient 

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

ConfigurationsClient contains the methods for the Configurations group. Don't use this type directly, use NewConfigurationsClient() instead.

func NewConfigurationsClient 

func NewConfigurationsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ConfigurationsClient, error)

NewConfigurationsClient creates a new instance of ConfigurationsClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ConfigurationsClient) BeginCreateOrUpdate 

func (client *ConfigurationsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, deploymentName string, configurationName string, options *ConfigurationsClientBeginCreateOrUpdateOptions) (*runtime.Poller[ConfigurationsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create or update the NGINX configuration for given NGINX deployment If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deploymentName - The name of targeted NGINX deployment
  • configurationName - The name of configuration, only 'default' is supported value due to the singleton of NGINX conf
  • options - ConfigurationsClientBeginCreateOrUpdateOptions contains the optional parameters for the ConfigurationsClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/nginx/resource-manager/NGINX.NGINXPLUS/stable/2023-04-01/examples/Configurations_CreateOrUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnginx.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewConfigurationsClient().BeginCreateOrUpdate(ctx, "myResourceGroup", "myDeployment", "default", &armnginx.ConfigurationsClientBeginCreateOrUpdateOptions{Body: 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.Configuration = armnginx.Configuration{
// 	Name: to.Ptr("default"),
// 	Type: to.Ptr("nginx.nginxplus/nginxDeployments/configurations"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Nginx.NginxPlus/nginxDeployments/myDeployment/configurations/default"),
// 	Properties: &armnginx.ConfigurationProperties{
// 		Files: []*armnginx.ConfigurationFile{
// 			{
// 				Content: to.Ptr("ABCDEF=="),
// 				VirtualPath: to.Ptr("/etc/nginx/nginx.conf"),
// 		}},
// 		Package: &armnginx.ConfigurationPackage{
// 		},
// 		ProvisioningState: to.Ptr(armnginx.ProvisioningStateSucceeded),
// 		RootFile: to.Ptr("/etc/nginx/nginx.conf"),
// 	},
// }

Output:

func (*ConfigurationsClient) BeginDelete 

func (client *ConfigurationsClient) BeginDelete(ctx context.Context, resourceGroupName string, deploymentName string, configurationName string, options *ConfigurationsClientBeginDeleteOptions) (*runtime.Poller[ConfigurationsClientDeleteResponse], error)

BeginDelete - Reset the NGINX configuration of given NGINX deployment to default If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deploymentName - The name of targeted NGINX deployment
  • configurationName - The name of configuration, only 'default' is supported value due to the singleton of NGINX conf
  • options - ConfigurationsClientBeginDeleteOptions contains the optional parameters for the ConfigurationsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/nginx/resource-manager/NGINX.NGINXPLUS/stable/2023-04-01/examples/Configurations_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnginx.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewConfigurationsClient().BeginDelete(ctx, "myResourceGroup", "myDeployment", "default", 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 (*ConfigurationsClient) Get 

func (client *ConfigurationsClient) Get(ctx context.Context, resourceGroupName string, deploymentName string, configurationName string, options *ConfigurationsClientGetOptions) (ConfigurationsClientGetResponse, error)

Get - Get the NGINX configuration of given NGINX deployment If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deploymentName - The name of targeted NGINX deployment
  • configurationName - The name of configuration, only 'default' is supported value due to the singleton of NGINX conf
  • options - ConfigurationsClientGetOptions contains the optional parameters for the ConfigurationsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/nginx/resource-manager/NGINX.NGINXPLUS/stable/2023-04-01/examples/Configurations_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnginx.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewConfigurationsClient().Get(ctx, "myResourceGroup", "myDeployment", "default", 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.Configuration = armnginx.Configuration{
// 	Name: to.Ptr("default"),
// 	Type: to.Ptr("nginx.nginxplus/nginxDeployments/configurations"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Nginx.NginxPlus/nginxDeployments/myDeployment/configurations/default"),
// 	Properties: &armnginx.ConfigurationProperties{
// 		Files: []*armnginx.ConfigurationFile{
// 			{
// 				Content: to.Ptr("ABCDEF=="),
// 				VirtualPath: to.Ptr("/etc/nginx/nginx.conf"),
// 		}},
// 		Package: &armnginx.ConfigurationPackage{
// 		},
// 		ProvisioningState: to.Ptr(armnginx.ProvisioningStateSucceeded),
// 		RootFile: to.Ptr("/etc/nginx/nginx.conf"),
// 	},
// }

Output:

func (*ConfigurationsClient) NewListPager 

func (client *ConfigurationsClient) NewListPager(resourceGroupName string, deploymentName string, options *ConfigurationsClientListOptions) *runtime.Pager[ConfigurationsClientListResponse]

NewListPager - List the NGINX configuration of given NGINX deployment.

Generated from API version 2023-04-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deploymentName - The name of targeted NGINX deployment
  • options - ConfigurationsClientListOptions contains the optional parameters for the ConfigurationsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/nginx/resource-manager/NGINX.NGINXPLUS/stable/2023-04-01/examples/Configurations_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnginx.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewConfigurationsClient().NewListPager("myResourceGroup", "myDeployment", 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.ConfigurationListResponse = armnginx.ConfigurationListResponse{
	// 	Value: []*armnginx.Configuration{
	// 		{
	// 			Name: to.Ptr("default"),
	// 			Type: to.Ptr("nginx.nginxplus/nginxDeployments/configurations"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Nginx.NginxPlus/nginxDeployments/myDeployment/configurations/default"),
	// 			Properties: &armnginx.ConfigurationProperties{
	// 				Files: []*armnginx.ConfigurationFile{
	// 					{
	// 						Content: to.Ptr("ABCDEF=="),
	// 						VirtualPath: to.Ptr("/etc/nginx/nginx.conf"),
	// 				}},
	// 				Package: &armnginx.ConfigurationPackage{
	// 				},
	// 				ProvisioningState: to.Ptr(armnginx.ProvisioningStateSucceeded),
	// 				RootFile: to.Ptr("/etc/nginx/nginx.conf"),
	// 			},
	// 	}},
	// }
}

Output:

type ConfigurationsClientBeginCreateOrUpdateOptions 

type ConfigurationsClientBeginCreateOrUpdateOptions struct {
	// The NGINX configuration
	Body *Configuration

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

ConfigurationsClientBeginCreateOrUpdateOptions contains the optional parameters for the ConfigurationsClient.BeginCreateOrUpdate method.

type ConfigurationsClientBeginDeleteOptions 

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

ConfigurationsClientBeginDeleteOptions contains the optional parameters for the ConfigurationsClient.BeginDelete method.

type ConfigurationsClientCreateOrUpdateResponse 

type ConfigurationsClientCreateOrUpdateResponse struct {
	Configuration
}

ConfigurationsClientCreateOrUpdateResponse contains the response from method ConfigurationsClient.BeginCreateOrUpdate.

type ConfigurationsClientDeleteResponse 

type ConfigurationsClientDeleteResponse struct {
}

ConfigurationsClientDeleteResponse contains the response from method ConfigurationsClient.BeginDelete.

type ConfigurationsClientGetOptions 

type ConfigurationsClientGetOptions struct {
}

ConfigurationsClientGetOptions contains the optional parameters for the ConfigurationsClient.Get method.

type ConfigurationsClientGetResponse 

type ConfigurationsClientGetResponse struct {
	Configuration
}

ConfigurationsClientGetResponse contains the response from method ConfigurationsClient.Get.

type ConfigurationsClientListOptions 

type ConfigurationsClientListOptions struct {
}

ConfigurationsClientListOptions contains the optional parameters for the ConfigurationsClient.NewListPager method.

type ConfigurationsClientListResponse 

type ConfigurationsClientListResponse struct {
	// Response of a list operation.
	ConfigurationListResponse
}

ConfigurationsClientListResponse contains the response from method ConfigurationsClient.NewListPager.

type CreatedByType 

type CreatedByType string

CreatedByType - The type of identity that created the resource. 

const (
	CreatedByTypeApplication     CreatedByType = "Application"
	CreatedByTypeKey             CreatedByType = "Key"
	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
	CreatedByTypeUser            CreatedByType = "User"
)

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type Deployment 

type Deployment struct {
	Identity   *IdentityProperties
	Location   *string
	Properties *DeploymentProperties
	SKU        *ResourceSKU

	// Dictionary of
	Tags map[string]*string

	// READ-ONLY
	ID *string

	// READ-ONLY
	Name *string

	// READ-ONLY; Metadata pertaining to creation and last modification of the resource.
	SystemData *SystemData

	// READ-ONLY
	Type *string
}

func (Deployment) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Deployment.

func (*Deployment) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Deployment.

type DeploymentListResponse 

type DeploymentListResponse struct {
	NextLink *string
	Value    []*Deployment
}

func (DeploymentListResponse) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DeploymentListResponse.

func (*DeploymentListResponse) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DeploymentListResponse.

type DeploymentProperties 

type DeploymentProperties struct {
	EnableDiagnosticsSupport *bool
	Logging                  *Logging

	// The managed resource group to deploy VNet injection related network resources.
	ManagedResourceGroup *string
	NetworkProfile       *NetworkProfile
	ScalingProperties    *DeploymentScalingProperties
	UserProfile          *DeploymentUserProfile

	// READ-ONLY; The IP address of the deployment.
	IPAddress *string

	// READ-ONLY
	NginxVersion *string

	// READ-ONLY
	ProvisioningState *ProvisioningState
}

func (DeploymentProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DeploymentProperties.

func (*DeploymentProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DeploymentProperties.

type DeploymentScalingProperties 

type DeploymentScalingProperties struct {
	Capacity *int32
}

func (DeploymentScalingProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DeploymentScalingProperties.

func (*DeploymentScalingProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DeploymentScalingProperties.

type DeploymentUpdateParameters 

type DeploymentUpdateParameters struct {
	Identity   *IdentityProperties
	Location   *string
	Properties *DeploymentUpdateProperties
	SKU        *ResourceSKU

	// Dictionary of
	Tags map[string]*string
}

func (DeploymentUpdateParameters) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DeploymentUpdateParameters.

func (*DeploymentUpdateParameters) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DeploymentUpdateParameters.

type DeploymentUpdateProperties 

type DeploymentUpdateProperties struct {
	EnableDiagnosticsSupport *bool
	Logging                  *Logging
	ScalingProperties        *DeploymentScalingProperties
	UserProfile              *DeploymentUserProfile
}

func (DeploymentUpdateProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DeploymentUpdateProperties.

func (*DeploymentUpdateProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DeploymentUpdateProperties.

type DeploymentUserProfile 

type DeploymentUserProfile struct {
	// The preferred support contact email address of the user used for sending alerts and notification. Can be an empty string
	// or a valid email address.
	PreferredEmail *string
}

func (DeploymentUserProfile) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DeploymentUserProfile.

func (*DeploymentUserProfile) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DeploymentUserProfile.

type DeploymentsClient 

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

DeploymentsClient contains the methods for the Deployments group. Don't use this type directly, use NewDeploymentsClient() instead.

func NewDeploymentsClient 

func NewDeploymentsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*DeploymentsClient, error)

NewDeploymentsClient creates a new instance of DeploymentsClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*DeploymentsClient) BeginCreateOrUpdate 

func (client *DeploymentsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, deploymentName string, options *DeploymentsClientBeginCreateOrUpdateOptions) (*runtime.Poller[DeploymentsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create or update the NGINX deployment If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deploymentName - The name of targeted NGINX deployment
  • options - DeploymentsClientBeginCreateOrUpdateOptions contains the optional parameters for the DeploymentsClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/nginx/resource-manager/NGINX.NGINXPLUS/stable/2023-04-01/examples/Deployments_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnginx.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewDeploymentsClient().BeginCreateOrUpdate(ctx, "myResourceGroup", "myDeployment", &armnginx.DeploymentsClientBeginCreateOrUpdateOptions{Body: 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.Deployment = armnginx.Deployment{
// 	Name: to.Ptr("myDeployment"),
// 	Type: to.Ptr("nginx.nginxplus/deployments"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Nginx.NginxPlus/nginxDeployments/myDeployment"),
// 	Location: to.Ptr("westus"),
// 	Properties: &armnginx.DeploymentProperties{
// 		IPAddress: to.Ptr("1.1.1.1"),
// 		ManagedResourceGroup: to.Ptr("myManagedResourceGroup"),
// 		NetworkProfile: &armnginx.NetworkProfile{
// 			FrontEndIPConfiguration: &armnginx.FrontendIPConfiguration{
// 				PrivateIPAddresses: []*armnginx.PrivateIPAddress{
// 					{
// 						PrivateIPAddress: to.Ptr("1.1.1.1"),
// 						PrivateIPAllocationMethod: to.Ptr(armnginx.NginxPrivateIPAllocationMethodStatic),
// 						SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet/subnets/mySubnet"),
// 				}},
// 				PublicIPAddresses: []*armnginx.PublicIPAddress{
// 					{
// 						ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/publicIPAddresses/myPublicIPAddress"),
// 				}},
// 			},
// 			NetworkInterfaceConfiguration: &armnginx.NetworkInterfaceConfiguration{
// 				SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet/subnets/mySubnet"),
// 			},
// 		},
// 		NginxVersion: to.Ptr("nginx-1.19.6"),
// 		ProvisioningState: to.Ptr(armnginx.ProvisioningStateSucceeded),
// 	},
// 	Tags: map[string]*string{
// 		"Environment": to.Ptr("Dev"),
// 	},
// }

Output:

func (*DeploymentsClient) BeginDelete 

func (client *DeploymentsClient) BeginDelete(ctx context.Context, resourceGroupName string, deploymentName string, options *DeploymentsClientBeginDeleteOptions) (*runtime.Poller[DeploymentsClientDeleteResponse], error)

BeginDelete - Delete the NGINX deployment resource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deploymentName - The name of targeted NGINX deployment
  • options - DeploymentsClientBeginDeleteOptions contains the optional parameters for the DeploymentsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/nginx/resource-manager/NGINX.NGINXPLUS/stable/2023-04-01/examples/Deployments_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnginx.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewDeploymentsClient().BeginDelete(ctx, "myResourceGroup", "myDeployment", 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 (*DeploymentsClient) BeginUpdate 

func (client *DeploymentsClient) BeginUpdate(ctx context.Context, resourceGroupName string, deploymentName string, options *DeploymentsClientBeginUpdateOptions) (*runtime.Poller[DeploymentsClientUpdateResponse], error)

BeginUpdate - Update the NGINX deployment If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deploymentName - The name of targeted NGINX deployment
  • options - DeploymentsClientBeginUpdateOptions contains the optional parameters for the DeploymentsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/nginx/resource-manager/NGINX.NGINXPLUS/stable/2023-04-01/examples/Deployments_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnginx.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewDeploymentsClient().BeginUpdate(ctx, "myResourceGroup", "myDeployment", &armnginx.DeploymentsClientBeginUpdateOptions{Body: 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.Deployment = armnginx.Deployment{
// 	Name: to.Ptr("myDeployment"),
// 	Type: to.Ptr("nginx.nginxplus/deployments"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Nginx.NginxPlus/nginxDeployments/myDeployment"),
// 	Location: to.Ptr("westus"),
// 	Properties: &armnginx.DeploymentProperties{
// 		IPAddress: to.Ptr("1.1.1.1"),
// 		ManagedResourceGroup: to.Ptr("myManagedResourceGroup"),
// 		NetworkProfile: &armnginx.NetworkProfile{
// 			FrontEndIPConfiguration: &armnginx.FrontendIPConfiguration{
// 				PrivateIPAddresses: []*armnginx.PrivateIPAddress{
// 					{
// 						PrivateIPAddress: to.Ptr("1.1.1.1"),
// 						PrivateIPAllocationMethod: to.Ptr(armnginx.NginxPrivateIPAllocationMethodStatic),
// 						SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet/subnets/mySubnet"),
// 				}},
// 				PublicIPAddresses: []*armnginx.PublicIPAddress{
// 					{
// 						ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/publicIPAddresses/myPublicIPAddress"),
// 				}},
// 			},
// 			NetworkInterfaceConfiguration: &armnginx.NetworkInterfaceConfiguration{
// 				SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet/subnets/mySubnet"),
// 			},
// 		},
// 		NginxVersion: to.Ptr("nginx-1.19.6"),
// 		ProvisioningState: to.Ptr(armnginx.ProvisioningStateSucceeded),
// 		UserProfile: &armnginx.DeploymentUserProfile{
// 			PreferredEmail: to.Ptr("example@example.email"),
// 		},
// 	},
// 	Tags: map[string]*string{
// 		"Environment": to.Ptr("Dev"),
// 	},
// }

Output:

func (*DeploymentsClient) Get 

func (client *DeploymentsClient) Get(ctx context.Context, resourceGroupName string, deploymentName string, options *DeploymentsClientGetOptions) (DeploymentsClientGetResponse, error)

Get - Get the NGINX deployment If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deploymentName - The name of targeted NGINX deployment
  • options - DeploymentsClientGetOptions contains the optional parameters for the DeploymentsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/nginx/resource-manager/NGINX.NGINXPLUS/stable/2023-04-01/examples/Deployments_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnginx.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewDeploymentsClient().Get(ctx, "myResourceGroup", "myDeployment", 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.Deployment = armnginx.Deployment{
// 	Name: to.Ptr("myDeployment"),
// 	Type: to.Ptr("nginx.nginxplus/deployments"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Nginx.NginxPlus/nginxDeployments/myDeployment"),
// 	Location: to.Ptr("westus"),
// 	Properties: &armnginx.DeploymentProperties{
// 		ManagedResourceGroup: to.Ptr("myManagedResourceGroup"),
// 		NetworkProfile: &armnginx.NetworkProfile{
// 			FrontEndIPConfiguration: &armnginx.FrontendIPConfiguration{
// 				PrivateIPAddresses: []*armnginx.PrivateIPAddress{
// 					{
// 						PrivateIPAddress: to.Ptr("1.1.1.1"),
// 						PrivateIPAllocationMethod: to.Ptr(armnginx.NginxPrivateIPAllocationMethodStatic),
// 						SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet/subnets/mySubnet"),
// 				}},
// 				PublicIPAddresses: []*armnginx.PublicIPAddress{
// 					{
// 						ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/publicIPAddresses/myPublicIPAddress"),
// 				}},
// 			},
// 			NetworkInterfaceConfiguration: &armnginx.NetworkInterfaceConfiguration{
// 				SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet/subnets/mySubnet"),
// 			},
// 		},
// 		NginxVersion: to.Ptr("nginx-1.19.6"),
// 		ProvisioningState: to.Ptr(armnginx.ProvisioningStateSucceeded),
// 		UserProfile: &armnginx.DeploymentUserProfile{
// 			PreferredEmail: to.Ptr("example@example.email"),
// 		},
// 	},
// }

Output:

func (*DeploymentsClient) NewListByResourceGroupPager 

func (client *DeploymentsClient) NewListByResourceGroupPager(resourceGroupName string, options *DeploymentsClientListByResourceGroupOptions) *runtime.Pager[DeploymentsClientListByResourceGroupResponse]

NewListByResourceGroupPager - List all NGINX deployments under the specified resource group.

Generated from API version 2023-04-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - DeploymentsClientListByResourceGroupOptions contains the optional parameters for the DeploymentsClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/nginx/resource-manager/NGINX.NGINXPLUS/stable/2023-04-01/examples/Deployments_ListByResourceGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnginx.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewDeploymentsClient().NewListByResourceGroupPager("myResourceGroup", 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.DeploymentListResponse = armnginx.DeploymentListResponse{
	// 	Value: []*armnginx.Deployment{
	// 		{
	// 			Name: to.Ptr("myDeployment"),
	// 			Type: to.Ptr("nginx.nginxplus/deployments"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Nginx.NginxPlus/nginxDeployments/myDeployment"),
	// 			Location: to.Ptr("westus"),
	// 			Properties: &armnginx.DeploymentProperties{
	// 				IPAddress: to.Ptr("1.1.1.1"),
	// 				ManagedResourceGroup: to.Ptr("myManagedResourceGroup"),
	// 				NetworkProfile: &armnginx.NetworkProfile{
	// 					FrontEndIPConfiguration: &armnginx.FrontendIPConfiguration{
	// 						PrivateIPAddresses: []*armnginx.PrivateIPAddress{
	// 							{
	// 								PrivateIPAddress: to.Ptr("1.1.1.1"),
	// 								PrivateIPAllocationMethod: to.Ptr(armnginx.NginxPrivateIPAllocationMethodStatic),
	// 								SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet/subnets/mySubnet"),
	// 						}},
	// 						PublicIPAddresses: []*armnginx.PublicIPAddress{
	// 							{
	// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/publicIPAddresses/myPublicIPAddress"),
	// 						}},
	// 					},
	// 					NetworkInterfaceConfiguration: &armnginx.NetworkInterfaceConfiguration{
	// 						SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet/subnets/mySubnet"),
	// 					},
	// 				},
	// 				NginxVersion: to.Ptr("nginx-1.19.6"),
	// 				ProvisioningState: to.Ptr(armnginx.ProvisioningStateSucceeded),
	// 			},
	// 	}},
	// }
}

Output:

func (*DeploymentsClient) NewListPager 

func (client *DeploymentsClient) NewListPager(options *DeploymentsClientListOptions) *runtime.Pager[DeploymentsClientListResponse]

NewListPager - List the NGINX deployments resources

Generated from API version 2023-04-01

  • options - DeploymentsClientListOptions contains the optional parameters for the DeploymentsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/nginx/resource-manager/NGINX.NGINXPLUS/stable/2023-04-01/examples/Deployments_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnginx.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewDeploymentsClient().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.DeploymentListResponse = armnginx.DeploymentListResponse{
	// 	Value: []*armnginx.Deployment{
	// 		{
	// 			Name: to.Ptr("myDeployment"),
	// 			Type: to.Ptr("nginx.nginxplus/deployments"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Nginx.NginxPlus/nginxDeployments/myDeployment"),
	// 			Location: to.Ptr("westus"),
	// 			Properties: &armnginx.DeploymentProperties{
	// 				IPAddress: to.Ptr("1.1.1.1"),
	// 				ManagedResourceGroup: to.Ptr("myManagedResourceGroup"),
	// 				NetworkProfile: &armnginx.NetworkProfile{
	// 					FrontEndIPConfiguration: &armnginx.FrontendIPConfiguration{
	// 						PrivateIPAddresses: []*armnginx.PrivateIPAddress{
	// 							{
	// 								PrivateIPAddress: to.Ptr("1.1.1.1"),
	// 								PrivateIPAllocationMethod: to.Ptr(armnginx.NginxPrivateIPAllocationMethodStatic),
	// 								SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet/subnets/mySubnet"),
	// 						}},
	// 						PublicIPAddresses: []*armnginx.PublicIPAddress{
	// 							{
	// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/publicIPAddresses/myPublicIPAddress"),
	// 						}},
	// 					},
	// 					NetworkInterfaceConfiguration: &armnginx.NetworkInterfaceConfiguration{
	// 						SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet/subnets/mySubnet"),
	// 					},
	// 				},
	// 				NginxVersion: to.Ptr("nginx-1.19.6"),
	// 				ProvisioningState: to.Ptr(armnginx.ProvisioningStateSucceeded),
	// 			},
	// 	}},
	// }
}

Output:

type DeploymentsClientBeginCreateOrUpdateOptions 

type DeploymentsClientBeginCreateOrUpdateOptions struct {
	Body *Deployment

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

DeploymentsClientBeginCreateOrUpdateOptions contains the optional parameters for the DeploymentsClient.BeginCreateOrUpdate method.

type DeploymentsClientBeginDeleteOptions 

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

DeploymentsClientBeginDeleteOptions contains the optional parameters for the DeploymentsClient.BeginDelete method.

type DeploymentsClientBeginUpdateOptions 

type DeploymentsClientBeginUpdateOptions struct {
	Body *DeploymentUpdateParameters

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

DeploymentsClientBeginUpdateOptions contains the optional parameters for the DeploymentsClient.BeginUpdate method.

type DeploymentsClientCreateOrUpdateResponse 

type DeploymentsClientCreateOrUpdateResponse struct {
	Deployment
}

DeploymentsClientCreateOrUpdateResponse contains the response from method DeploymentsClient.BeginCreateOrUpdate.

type DeploymentsClientDeleteResponse 

type DeploymentsClientDeleteResponse struct {
}

DeploymentsClientDeleteResponse contains the response from method DeploymentsClient.BeginDelete.

type DeploymentsClientGetOptions 

type DeploymentsClientGetOptions struct {
}

DeploymentsClientGetOptions contains the optional parameters for the DeploymentsClient.Get method.

type DeploymentsClientGetResponse 

type DeploymentsClientGetResponse struct {
	Deployment
}

DeploymentsClientGetResponse contains the response from method DeploymentsClient.Get.

type DeploymentsClientListByResourceGroupOptions 

type DeploymentsClientListByResourceGroupOptions struct {
}

DeploymentsClientListByResourceGroupOptions contains the optional parameters for the DeploymentsClient.NewListByResourceGroupPager method.

type DeploymentsClientListByResourceGroupResponse 

type DeploymentsClientListByResourceGroupResponse struct {
	DeploymentListResponse
}

DeploymentsClientListByResourceGroupResponse contains the response from method DeploymentsClient.NewListByResourceGroupPager.

type DeploymentsClientListOptions 

type DeploymentsClientListOptions struct {
}

DeploymentsClientListOptions contains the optional parameters for the DeploymentsClient.NewListPager method.

type DeploymentsClientListResponse 

type DeploymentsClientListResponse struct {
	DeploymentListResponse
}

DeploymentsClientListResponse contains the response from method DeploymentsClient.NewListPager.

type DeploymentsClientUpdateResponse 

type DeploymentsClientUpdateResponse struct {
	Deployment
}

DeploymentsClientUpdateResponse contains the response from method DeploymentsClient.BeginUpdate.

type ErrorResponseBody 

type ErrorResponseBody struct {
	Code    *string
	Details []*ErrorResponseBody
	Message *string
	Target  *string
}

func (ErrorResponseBody) MarshalJSON 

func (e ErrorResponseBody) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ErrorResponseBody.

func (*ErrorResponseBody) UnmarshalJSON 

func (e *ErrorResponseBody) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorResponseBody.

type FrontendIPConfiguration 

type FrontendIPConfiguration struct {
	PrivateIPAddresses []*PrivateIPAddress
	PublicIPAddresses  []*PublicIPAddress
}

func (FrontendIPConfiguration) MarshalJSON 

func (f FrontendIPConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type FrontendIPConfiguration.

func (*FrontendIPConfiguration) UnmarshalJSON 

func (f *FrontendIPConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type FrontendIPConfiguration.

type IdentityProperties 

type IdentityProperties struct {
	Type *IdentityType

	// Dictionary of
	UserAssignedIdentities map[string]*UserIdentityProperties

	// READ-ONLY
	PrincipalID *string

	// READ-ONLY
	TenantID *string
}

func (IdentityProperties) MarshalJSON 

func (i IdentityProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IdentityProperties.

func (*IdentityProperties) UnmarshalJSON 

func (i *IdentityProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IdentityProperties.

type IdentityType 

type IdentityType string
const (
	IdentityTypeNone                       IdentityType = "None"
	IdentityTypeSystemAssigned             IdentityType = "SystemAssigned"
	IdentityTypeSystemAssignedUserAssigned IdentityType = "SystemAssigned, UserAssigned"
	IdentityTypeUserAssigned               IdentityType = "UserAssigned"
)

func PossibleIdentityTypeValues 

func PossibleIdentityTypeValues() []IdentityType

PossibleIdentityTypeValues returns the possible values for the IdentityType const type.

type Logging 

type Logging struct {
	StorageAccount *StorageAccount
}

func (Logging) MarshalJSON 

func (l Logging) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Logging.

func (*Logging) UnmarshalJSON 

func (l *Logging) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Logging.

type NetworkInterfaceConfiguration 

type NetworkInterfaceConfiguration struct {
	SubnetID *string
}

func (NetworkInterfaceConfiguration) MarshalJSON 

func (n NetworkInterfaceConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkInterfaceConfiguration.

func (*NetworkInterfaceConfiguration) UnmarshalJSON 

func (n *NetworkInterfaceConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkInterfaceConfiguration.

type NetworkProfile 

type NetworkProfile struct {
	FrontEndIPConfiguration       *FrontendIPConfiguration
	NetworkInterfaceConfiguration *NetworkInterfaceConfiguration
}

func (NetworkProfile) MarshalJSON 

func (n NetworkProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkProfile.

func (*NetworkProfile) UnmarshalJSON 

func (n *NetworkProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkProfile.

type NginxPrivateIPAllocationMethod 

type NginxPrivateIPAllocationMethod string
const (
	NginxPrivateIPAllocationMethodDynamic NginxPrivateIPAllocationMethod = "Dynamic"
	NginxPrivateIPAllocationMethodStatic  NginxPrivateIPAllocationMethod = "Static"
)

func PossibleNginxPrivateIPAllocationMethodValues 

func PossibleNginxPrivateIPAllocationMethodValues() []NginxPrivateIPAllocationMethod

PossibleNginxPrivateIPAllocationMethodValues returns the possible values for the NginxPrivateIPAllocationMethod const type.

type OperationDisplay 

type OperationDisplay struct {
	// Description of the operation, e.g., 'Write deployments'.
	Description *string

	// Operation type, e.g., read, write, delete, etc.
	Operation *string

	// Service provider: Nginx.NginxPlus
	Provider *string

	// Type on which the operation is performed, e.g., 'deployments'.
	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 OperationListResult 

type OperationListResult struct {
	// URL to get the next set of operation list results if there are any.
	NextLink *string

	// List of operations supported by the Nginx.NginxPlus provider.
	Value []*OperationResult
}

OperationListResult - Result of GET request to list Nginx.NginxPlus operations.

func (OperationListResult) MarshalJSON 

func (o OperationListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON 

func (o *OperationListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

type OperationResult 

type OperationResult struct {
	// The object that represents the operation.
	Display *OperationDisplay

	// Indicates whether the operation is a data action
	IsDataAction *bool

	// Operation name: {provider}/{resource}/{operation}
	Name *string
}

OperationResult - A Nginx.NginxPlus REST API operation.

func (OperationResult) MarshalJSON 

func (o OperationResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationResult.

func (*OperationResult) UnmarshalJSON 

func (o *OperationResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationResult.

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 - List all operations provided by Nginx.NginxPlus for the 2023-04-01 api version.

Generated from API version 2023-04-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/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/nginx/resource-manager/NGINX.NGINXPLUS/stable/2023-04-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 := armnginx.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.OperationListResult = armnginx.OperationListResult{
	// 	Value: []*armnginx.OperationResult{
	// 		{
	// 			Name: to.Ptr("Nginx.NginxPlus/nginxDeployments/write"),
	// 			Display: &armnginx.OperationDisplay{
	// 				Description: to.Ptr("Write deployments resource"),
	// 				Operation: to.Ptr("write"),
	// 				Provider: to.Ptr("Nginx.NginxPlus"),
	// 				Resource: to.Ptr("deployments"),
	// 			},
	// 	}},
	// }
}

Output:

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	// Result of GET request to list Nginx.NginxPlus operations.
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type PrivateIPAddress 

type PrivateIPAddress struct {
	PrivateIPAddress          *string
	PrivateIPAllocationMethod *NginxPrivateIPAllocationMethod
	SubnetID                  *string
}

func (PrivateIPAddress) MarshalJSON 

func (p PrivateIPAddress) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateIPAddress.

func (*PrivateIPAddress) UnmarshalJSON 

func (p *PrivateIPAddress) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateIPAddress.

type ProvisioningState 

type ProvisioningState string
const (
	ProvisioningStateAccepted     ProvisioningState = "Accepted"
	ProvisioningStateCanceled     ProvisioningState = "Canceled"
	ProvisioningStateCreating     ProvisioningState = "Creating"
	ProvisioningStateDeleted      ProvisioningState = "Deleted"
	ProvisioningStateDeleting     ProvisioningState = "Deleting"
	ProvisioningStateFailed       ProvisioningState = "Failed"
	ProvisioningStateNotSpecified ProvisioningState = "NotSpecified"
	ProvisioningStateSucceeded    ProvisioningState = "Succeeded"
	ProvisioningStateUpdating     ProvisioningState = "Updating"
)

func PossibleProvisioningStateValues 

func PossibleProvisioningStateValues() []ProvisioningState

PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.

type PublicIPAddress 

type PublicIPAddress struct {
	ID *string
}

func (PublicIPAddress) MarshalJSON 

func (p PublicIPAddress) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PublicIPAddress.

func (*PublicIPAddress) UnmarshalJSON 

func (p *PublicIPAddress) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PublicIPAddress.

type ResourceProviderDefaultErrorResponse 

type ResourceProviderDefaultErrorResponse struct {
	Error *ErrorResponseBody
}

func (ResourceProviderDefaultErrorResponse) MarshalJSON 

func (r ResourceProviderDefaultErrorResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceProviderDefaultErrorResponse.

func (*ResourceProviderDefaultErrorResponse) UnmarshalJSON 

func (r *ResourceProviderDefaultErrorResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceProviderDefaultErrorResponse.

type ResourceSKU 

type ResourceSKU struct {
	// REQUIRED; Name of the SKU.
	Name *string
}

func (ResourceSKU) MarshalJSON 

func (r ResourceSKU) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceSKU.

func (*ResourceSKU) UnmarshalJSON 

func (r *ResourceSKU) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceSKU.

type StorageAccount 

type StorageAccount struct {
	AccountName   *string
	ContainerName *string
}

func (StorageAccount) MarshalJSON 

func (s StorageAccount) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type StorageAccount.

func (*StorageAccount) UnmarshalJSON 

func (s *StorageAccount) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type StorageAccount.

type SystemData 

type SystemData struct {
	// The timestamp of resource creation (UTC).
	CreatedAt *time.Time

	// The identity that created the resource.
	CreatedBy *string

	// The type of identity that created the resource.
	CreatedByType *CreatedByType

	// The timestamp of resource last modification (UTC)
	LastModifiedAt *time.Time

	// The identity that last modified the resource.
	LastModifiedBy *string

	// The type of identity that last modified the resource.
	LastModifiedByType *CreatedByType
}

SystemData - Metadata pertaining to creation and last modification of the resource.

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 UserIdentityProperties 

type UserIdentityProperties struct {
	// READ-ONLY
	ClientID *string

	// READ-ONLY
	PrincipalID *string
}

func (UserIdentityProperties) MarshalJSON 

func (u UserIdentityProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UserIdentityProperties.

func (*UserIdentityProperties) UnmarshalJSON 

func (u *UserIdentityProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UserIdentityProperties.

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.