diff --git a/azure/plugin.go b/azure/plugin.go index a371459f..a10577ed 100644 --- a/azure/plugin.go +++ b/azure/plugin.go @@ -127,6 +127,8 @@ func Plugin(ctx context.Context) *plugin.Plugin { "azure_lb_outbound_rule": tableAzureLoadBalancerOutboundRule(ctx), "azure_lb_probe": tableAzureLoadBalancerProbe(ctx), "azure_lb_rule": tableAzureLoadBalancerRule(ctx), + "azure_lighthouse_assignment": tableAzureLighthouseAssignment(ctx), + "azure_lighthouse_definition": tableAzureLighthouseDefinition(ctx), "azure_location": tableAzureLocation(ctx), "azure_log_alert": tableAzureLogAlert(ctx), "azure_log_analytics_workspace": tableAzureLogAnalyticsWorkspace(ctx), diff --git a/azure/table_azure_lighthouse_assignment.go b/azure/table_azure_lighthouse_assignment.go new file mode 100644 index 00000000..d7929dcb --- /dev/null +++ b/azure/table_azure_lighthouse_assignment.go @@ -0,0 +1,196 @@ +package azure + +import ( + "context" + "strings" + + "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managedservices/armmanagedservices" + "github.com/turbot/steampipe-plugin-sdk/v5/grpc/proto" + "github.com/turbot/steampipe-plugin-sdk/v5/plugin" + "github.com/turbot/steampipe-plugin-sdk/v5/plugin/transform" +) + +//// TABLE DEFINITION + +func tableAzureLighthouseAssignment(_ context.Context) *plugin.Table { + return &plugin.Table{ + Name: "azure_lighthouse_assignment", + Description: "Azure Lighthouse Assignment", + DefaultIgnoreConfig: &plugin.IgnoreConfig{ + ShouldIgnoreErrorFunc: isNotFoundError([]string{"SubscriptionNotFound"}), + }, + Get: &plugin.GetConfig{ + KeyColumns: plugin.KeyColumnSlice{ + { + Name: "registration_assignment_id", + Require: plugin.Required, + }, + { + Name: "scope", + Require: plugin.Optional, + Operators: []string{"="}, + }, + }, + Hydrate: getAzureLighthouseAssignment, + IgnoreConfig: &plugin.IgnoreConfig{ + ShouldIgnoreErrorFunc: isNotFoundError([]string{"RegistrationAssignmentNotFound"}), + }, + }, + List: &plugin.ListConfig{ + Hydrate: listAzureLighthouseAssignments, + KeyColumns: plugin.OptionalColumns([]string{"scope"}), + }, + Columns: []*plugin.Column{ + { + Name: "name", + Description: "Name of the registration assignment.", + Type: proto.ColumnType_STRING, + }, + { + Name: "id", + Description: "Fully qualified path of the registration assignment.", + Type: proto.ColumnType_STRING, + Transform: transform.FromField("ID"), + }, + { + Name: "registration_assignment_id", + Description: "The ID of the registration assignment.", + Type: proto.ColumnType_STRING, + Transform: transform.FromField("ID").Transform(lastPathElement), + }, + { + Name: "type", + Description: "Type of the resource.", + Type: proto.ColumnType_STRING, + }, + { + Name: "scope", + Description: "The scope of the resource.", + Type: proto.ColumnType_STRING, + Transform: transform.FromQual("scope"), + }, + { + Name: "registration_definition_id", + Description: "ID of the associated registration definition.", + Type: proto.ColumnType_STRING, + Transform: transform.FromField("Properties.RegistrationDefinitionID"), + }, + { + Name: "provisioning_state", + Description: "Provisioning state of the registration assignment.", + Type: proto.ColumnType_STRING, + Transform: transform.FromField("Properties.ProvisioningState"), + }, + + // Steampipe standard columns + { + Name: "title", + Description: ColumnDescriptionTitle, + Type: proto.ColumnType_STRING, + Transform: transform.FromField("Name"), + }, + { + Name: "akas", + Description: ColumnDescriptionAkas, + Type: proto.ColumnType_JSON, + Transform: transform.FromField("ID").Transform(idToAkas), + }, + + // Azure standard columns + { + Name: "resource_group", + Description: ColumnDescriptionResourceGroup, + Type: proto.ColumnType_STRING, + Hydrate: getLighthouseAssignmentResourceGroup, + Transform: transform.FromValue(), + }, + }, + } +} + +//// LIST FUNCTION + +func listAzureLighthouseAssignments(ctx context.Context, d *plugin.QueryData, h *plugin.HydrateData) (interface{}, error) { + session, err := GetNewSessionUpdated(ctx, d) + if err != nil { + plugin.Logger(ctx).Error("azure_lighthouse_assignment.listAzureLighthouseAssignments", "session_error", err) + return nil, err + } + clientFactory, err := armmanagedservices.NewRegistrationAssignmentsClient(session.Cred, session.ClientOptions) + + scope := d.EqualsQualString("scope") + if scope == "" { + scope = "subscriptions/" + session.SubscriptionID + } + + pager := clientFactory.NewListPager(scope, &armmanagedservices.RegistrationAssignmentsClientListOptions{}) + for pager.More() { + page, err := pager.NextPage(ctx) + if err != nil { + plugin.Logger(ctx).Error("azure_lighthouse_assignment.listAzureLighthouseAssignments", "api_error", err) + return nil, err + } + for _, assignment := range page.Value { + d.StreamListItem(ctx, assignment) + if d.RowsRemaining(ctx) == 0 { + return nil, nil + } + } + } + return nil, err +} + +//// HYDRATE FUNCTION + +func getAzureLighthouseAssignment(ctx context.Context, d *plugin.QueryData, h *plugin.HydrateData) (interface{}, error) { + id := d.EqualsQualString("registration_assignment_id") + + session, err := GetNewSessionUpdated(ctx, d) + if err != nil { + plugin.Logger(ctx).Error("azure_lighthouse_assignment.getAzureLighthouseAssignment", "session_error", err) + return nil, err + } + scope := d.EqualsQualString("scope") + if scope == "" { + scope = "subscriptions/" + session.SubscriptionID + } + + clientFactory, err := armmanagedservices.NewRegistrationAssignmentsClient(session.Cred, session.ClientOptions) + + if err != nil { + plugin.Logger(ctx).Error("azure_lighthouse_assignment.getAzureLighthouseAssignment", "client_error", err) + return nil, err + } + + result, err := clientFactory.Get(ctx, scope, id, nil) + if err != nil { + plugin.Logger(ctx).Error("azure_lighthouse_assignment.getAzureLighthouseAssignment", "api_error", err) + return nil, err + } + return result, nil +} + +// We can have Definition/Assignments in different scopes: +// Subscription: /subscriptions/{subscription-id} +// Resource Groups: /subscriptions/{subscription-id}/resourceGroups/{resource-group-name} +// Management Groups: /providers/Microsoft.Management/managementGroups/{management-group-id} +// Individual Resources: /subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/{resource-provider}/{resource-type}/{resource-name} +func getLighthouseAssignmentResourceGroup(ctx context.Context, d *plugin.QueryData, h *plugin.HydrateData) (interface{}, error) { + if h.Item == nil { + return nil, nil + } + + id := "" + switch item := h.Item.(type) { + case *armmanagedservices.RegistrationAssignment: + id = *item.ID + case armmanagedservices.RegistrationAssignmentsClientGetResponse: + id = *item.ID + } + + if id != "" && strings.Contains(strings.ToLower(id), "/resourcegroups/") { + return strings.Split(id, "/")[4], nil + } + + return nil, nil +} diff --git a/azure/table_azure_lighthouse_definition.go b/azure/table_azure_lighthouse_definition.go new file mode 100644 index 00000000..2ee46c28 --- /dev/null +++ b/azure/table_azure_lighthouse_definition.go @@ -0,0 +1,231 @@ +package azure + +import ( + "context" + "strings" + + "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managedservices/armmanagedservices" + "github.com/turbot/steampipe-plugin-sdk/v5/grpc/proto" + "github.com/turbot/steampipe-plugin-sdk/v5/plugin" + "github.com/turbot/steampipe-plugin-sdk/v5/plugin/transform" +) + +//// TABLE DEFINITION + +func tableAzureLighthouseDefinition(_ context.Context) *plugin.Table { + return &plugin.Table{ + Name: "azure_lighthouse_definition", + Description: "Azure Lighthouse Definition", + DefaultIgnoreConfig: &plugin.IgnoreConfig{ + ShouldIgnoreErrorFunc: isNotFoundError([]string{"SubscriptionNotFound"}), + }, + Get: &plugin.GetConfig{ + KeyColumns: plugin.KeyColumnSlice{ + { + Name: "registration_definition_id", + Require: plugin.Required, + }, + { + Name: "scope", + Require: plugin.Optional, + Operators: []string{"="}, + }, + }, + Hydrate: getAzureLighthouseDefinition, + IgnoreConfig: &plugin.IgnoreConfig{ + ShouldIgnoreErrorFunc: isNotFoundError([]string{"RegistrationDefinitionNotFound"}), + }, + }, + List: &plugin.ListConfig{ + Hydrate: listAzureLighthouseDefinitions, + KeyColumns: plugin.OptionalColumns([]string{"scope"}), + }, + Columns: []*plugin.Column{ + { + Name: "name", + Description: "Name of the registration definition.", + Type: proto.ColumnType_STRING, + }, + { + Name: "id", + Description: "Fully qualified path of the registration definition.", + Type: proto.ColumnType_STRING, + Transform: transform.FromField("ID"), + }, + { + Name: "registration_definition_id", + Description: "The ID of the registration definition.", + Type: proto.ColumnType_STRING, + Transform: transform.FromField("ID").Transform(lastPathElement), + }, + { + Name: "type", + Description: "Type of the resource.", + Type: proto.ColumnType_STRING, + }, + { + Name: "scope", + Description: "The scope of the resource.", + Type: proto.ColumnType_STRING, + Transform: transform.FromQual("scope"), + }, + { + Name: "description", + Description: "Description of the registration definition.", + Type: proto.ColumnType_STRING, + Transform: transform.FromField("Properties.Description"), + }, + { + Name: "registration_definition_name", + Description: "Name of the registration definition.", + Type: proto.ColumnType_STRING, + Transform: transform.FromField("Properties.RegistrationDefinitionName"), + }, + { + Name: "managed_by_tenant_id", + Description: "ID of the managedBy tenant.", + Type: proto.ColumnType_STRING, + Transform: transform.FromField("Properties.ManagedByTenantID"), + }, + { + Name: "managed_by_tenant_name", + Description: "The name of the managedBy tenant.", + Type: proto.ColumnType_STRING, + Transform: transform.FromField("Properties.ManagedByTenantName"), + }, + { + Name: "managed_tenant_name", + Description: "The name of the managed tenant.", + Type: proto.ColumnType_STRING, + Transform: transform.FromField("Properties.ManageeTenantName"), + }, + { + Name: "authorizations", + Description: "Authorization details containing principal ID and role ID.", + Type: proto.ColumnType_JSON, + Transform: transform.FromField("Properties.Authorizations"), + }, + { + Name: "eligible_authorizations", + Description: "The collection of eligible authorization objects describing the just-in-time access Azure Active Directory principals in the managedBy tenant will receive on the delegated resource in the managed tenant.", + Type: proto.ColumnType_JSON, + Transform: transform.FromField("Properties.EligibleAuthorizations"), + }, + { + Name: "plan", + Description: "Plan details for the managed services.", + Type: proto.ColumnType_JSON, + }, + + // Steampipe standard columns + { + Name: "title", + Description: ColumnDescriptionTitle, + Type: proto.ColumnType_STRING, + Transform: transform.FromField("Name"), + }, + { + Name: "akas", + Description: ColumnDescriptionAkas, + Type: proto.ColumnType_JSON, + Transform: transform.FromField("ID").Transform(idToAkas), + }, + + // Azure standard columns + { + Name: "resource_group", + Description: ColumnDescriptionResourceGroup, + Type: proto.ColumnType_STRING, + Hydrate: getLighthouseDefinitionResourceGroup, + Transform: transform.FromValue(), + }, + }, + } +} + +//// LIST FUNCTION + +func listAzureLighthouseDefinitions(ctx context.Context, d *plugin.QueryData, h *plugin.HydrateData) (interface{}, error) { + session, err := GetNewSessionUpdated(ctx, d) + if err != nil { + plugin.Logger(ctx).Error("azure_lighthouse_definition.listAzureLighthouseDefinitions", "session_error", err) + return nil, err + } + clientFactory, err := armmanagedservices.NewRegistrationDefinitionsClient(session.Cred, session.ClientOptions) + + scope := d.EqualsQualString("scope") + if scope == "" { + scope = "subscriptions/" + session.SubscriptionID + } + + pager := clientFactory.NewListPager(scope, &armmanagedservices.RegistrationDefinitionsClientListOptions{}) + for pager.More() { + page, err := pager.NextPage(ctx) + if err != nil { + plugin.Logger(ctx).Error("azure_lighthouse_definition.listAzureLighthouseDefinitions", "api_error", err) + return nil, err + } + for _, definition := range page.Value { + d.StreamListItem(ctx, definition) + if d.RowsRemaining(ctx) == 0 { + return nil, nil + } + } + } + return nil, err +} + +//// HYDRATE FUNCTION + +func getAzureLighthouseDefinition(ctx context.Context, d *plugin.QueryData, h *plugin.HydrateData) (interface{}, error) { + id := d.EqualsQualString("registration_definition_id") + + session, err := GetNewSessionUpdated(ctx, d) + if err != nil { + plugin.Logger(ctx).Error("azure_lighthouse_definition.getAzureLighthouseDefinition", "session_error", err) + return nil, err + } + scope := d.EqualsQualString("scope") + if scope == "" { + scope = "subscriptions/" + session.SubscriptionID + } + + clientFactory, err := armmanagedservices.NewRegistrationDefinitionsClient(session.Cred, session.ClientOptions) + + if err != nil { + plugin.Logger(ctx).Error("azure_lighthouse_definition.getAzureLighthouseDefinition", "client_error", err) + return nil, err + } + + result, err := clientFactory.Get(ctx, scope, id, nil) + if err != nil { + plugin.Logger(ctx).Error("azure_lighthouse_definition.getAzureLighthouseDefinition", "api_error", err) + return nil, err + } + return result, nil +} + +// We can have Definition/Assignments in different scopes: +// Subscription: /subscriptions/{subscription-id} +// Resource Groups: /subscriptions/{subscription-id}/resourceGroups/{resource-group-name} +// Management Groups: /providers/Microsoft.Management/managementGroups/{management-group-id} +// Individual Resources: /subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/{resource-provider}/{resource-type}/{resource-name} +func getLighthouseDefinitionResourceGroup(ctx context.Context, d *plugin.QueryData, h *plugin.HydrateData) (interface{}, error) { + if h.Item == nil { + return nil, nil + } + + id := "" + switch item := h.Item.(type) { + case *armmanagedservices.RegistrationDefinition: + id = *item.ID + case armmanagedservices.RegistrationDefinitionsClientGetResponse: + id = *item.ID + } + + if id != "" && strings.Contains(strings.ToLower(id), "/resourcegroups/") { + return strings.Split(id, "/")[4], nil + } + + return nil, nil +} diff --git a/docs/tables/azure_lighthouse_assignment.md b/docs/tables/azure_lighthouse_assignment.md new file mode 100644 index 00000000..e2827945 --- /dev/null +++ b/docs/tables/azure_lighthouse_assignment.md @@ -0,0 +1,171 @@ +--- +title: "Steampipe Table: azure_lighthouse_assignment - Query Azure Lighthouse Assignments using SQL" +description: "Allows users to query Azure Lighthouse assignments, providing insights into the management and governance of resources across multiple tenants." +--- + +# Table: azure_lighthouse_assignment - Query Azure Lighthouse Assignments using SQL + +Azure Lighthouse is a service within Microsoft Azure that enables cross-tenant management, allowing service providers to manage resources across multiple tenants while maintaining control and visibility. Azure Lighthouse assignments are specific configurations that apply these management capabilities to designated resources. + +## Table Usage Guide + +The `azure_lighthouse_assignment` table provides insights into Azure Lighthouse assignments. As a Network Administrator or Service Provider, you can explore details about each assignment, including its configuration, provisioning state, and associated registration definition. Use this table to ensure your cross-tenant management and governance assignments are correctly configured and to quickly identify any potential issues. + +## Examples + +### Basic info +Explore the status and details of your Azure Lighthouse assignments to understand their current state and type. This is beneficial for auditing and managing your cross-tenant resources effectively. + +```sql+postgres +select + name, + id, + provisioning_state, + registration_assignment_id, + registration_definition_id, + type +from + azure_lighthouse_assignment; +``` + +```sql+sqlite +select + name, + id, + provisioning_state, + registration_assignment_id, + registration_definition_id, + type +from + azure_lighthouse_assignment; +``` + +### List assignments by resource group +Identify the Azure Lighthouse assignments based on their resource group. This can help in organizing and managing assignments within specific resource groups. + +```sql+postgres +select + name, + id, + resource_group, + scope, + type +from + azure_lighthouse_assignment +where + resource_group = 'your_resource_group_name'; +``` + +```sql+sqlite +select + name, + id, + resource_group, + scope, + type +from + azure_lighthouse_assignment +where + resource_group = 'your_resource_group_name'; +``` + +### List assignments with specific provisioning state +Explore the Azure Lighthouse assignments that have a specific provisioning state. This helps in monitoring the status and ensuring that assignments are correctly provisioned. + +```sql+postgres +select + name, + id, + provisioning_state, + scope, + type +from + azure_lighthouse_assignment +where + provisioning_state = 'Succeeded'; +``` + +```sql+sqlite +select + name, + id, + provisioning_state, + scope, + type +from + azure_lighthouse_assignment +where + provisioning_state = 'Succeeded'; +``` + +### List assignments by scope +Get an overview of Azure Lighthouse assignments based on their scope. This can assist in understanding the management scope and ensuring it aligns with your governance requirements. + +```sql+postgres +select + name, + id, + scope, + registration_definition_id, + type +from + azure_lighthouse_assignment +where + scope = '/subscriptions/your_subscription_id'; +``` + +```sql+sqlite +select + name, + id, + scope, + registration_definition_id, + type +from + azure_lighthouse_assignment +where + scope = '/subscriptions/your_subscription_id'; +``` + +### Determine the scope for assignments +This query is highly useful for normalizing, analyzing, and reporting on Azure resource scopes in an environment managed by Azure Lighthouse. + +```sql+postgres +select + case + when id like '/subscriptions/%/resourceGroups/%/providers/%/%/%' then + substring(id from '/subscriptions/[^/]+/resourceGroups/[^/]+/providers/[^/]+/[^/]+/[^/]+') + when id like '/subscriptions/%/resourceGroups/%' then + substring(id from '/subscriptions/[^/]+/resourceGroups/[^/]+') + when id like '/subscriptions/%' then + substring(id from '/subscriptions/[^/]+') + when id like '/providers/Microsoft.Management/managementGroups/%' then + substring(id from '/providers/Microsoft.Management/managementGroups/[^/]+') + else + null + end as scope_id, + registration_definition_id, + id +from + azure_lighthouse_assignment; +``` + +```sql+sqlite +select + case + when id like '/subscriptions/%/resourceGroups/%/providers/%/%/%' then + substr(id, 1, instr(id, '/', 3, 5) + length('/providers') - 1) + when id like '/subscriptions/%/resourceGroups/%' then + substr(id, 1, instr(id, '/', 3, 4) + length('/resourceGroups') - 1) + when id like '/subscriptions/%' then + substr(id, 1, instr(id, '/', 3, 2) - 1) + when id like '/providers/Microsoft.Management/managementGroups/%' then + substr(id, 1, instr(id, '/', 3, 4) + length('/managementGroups') - 1) + else + null + end as scope_id, + registration_definition_id, + id +from + azure_lighthouse_assignment; +``` diff --git a/docs/tables/azure_lighthouse_definition.md b/docs/tables/azure_lighthouse_definition.md new file mode 100644 index 00000000..a0316c36 --- /dev/null +++ b/docs/tables/azure_lighthouse_definition.md @@ -0,0 +1,120 @@ +--- +title: "Steampipe Table: azure_lighthouse_definition - Query Azure Lighthouse Definitions using SQL" +description: "Allows users to query Azure Lighthouse definitions, providing insights into cross-tenant management and governance." +--- + +# Table: azure_lighthouse_definition - Query Azure Lighthouse Definitions using SQL + +Azure Lighthouse is a service within Microsoft Azure that enables cross-tenant management, allowing service providers to manage resources across multiple tenants while maintaining control and visibility. Azure Lighthouse provides greater automation, scalability, and enhanced governance across resources. + +## Table Usage Guide + +The `azure_lighthouse_definition` table provides insights into Azure Lighthouse definitions. As a Network Administrator or Service Provider, you can explore details about each Lighthouse definition, including its configuration, associated resources, and authorization details. Use this table to ensure your cross-tenant management and governance are correctly configured and to quickly identify any potential issues. + +## Examples + +### Basic info +Explore the status and details of your Azure Lighthouse definitions to understand their current state and type. This is beneficial for auditing and managing your cross-tenant resources effectively. + +```sql+postgres +select + name, + id, + managed_by_tenant_id, + managed_by_tenant_name, + managed_tenant_name, + type +from + azure_lighthouse_definition; +``` + +```sql+sqlite +select + name, + id, + managed_by_tenant_id, + managed_by_tenant_name, + managed_tenant_name, + type +from + azure_lighthouse_definition; +``` + +### List authorization details for each Lighthouse definition +Identify the authorization details linked with each Lighthouse definition. This can help in managing access control and understanding the roles assigned to different Azure Active Directory principals. + +```sql+postgres +select + name, + a ->> 'principalId' as principal_id, + a ->> 'roleDefinitionId' as role_definition_id, + a ->> 'principalIdDisplayName' as principal_id_display_name, + a -> 'delegatedRoleDefinitionIds' as delegated_role_definition_i_ds +from + azure_lighthouse_definition, + jsonb_array_elements(authorizations) as a; +``` + +```sql+sqlite +select + name, + json_extract(a.value, '$.principalId') as principal_id, + json_extract(a.value, '$.roleDefinitionId') as role_definition_id, + json_extract(a.value, '$.principalIdDisplayName') as principal_id_display_name, + json_extract(a.value, '$.delegatedRoleDefinitionIds') as delegated_role_definition_i_ds +from + azure_lighthouse_definition, + json_each(authorizations) as a; +``` + +### List eligible authorization details for each Lighthouse definition +Explore the eligible authorization details associated with each Lighthouse definition. This helps in understanding the just-in-time access Azure Active Directory principals will receive on the delegated resources. + +```sql+postgres +select + name, + a ->> 'principalId' as principal_id, + a ->> 'roleDefinitionId' as role_definition_id, + a ->> 'principalIdDisplayName' as principal_id_display_name, + a -> 'justInTimeAccessPolicy' as just_in_time_access_policy +from + azure_lighthouse_definition, + jsonb_array_elements(eligible_authorizations) as a; +``` + +```sql+sqlite +select + name, + json_extract(a.value, '$.principalId') as principal_id, + json_extract(a.value, '$.roleDefinitionId') as role_definition_id, + json_extract(a.value, '$.principalIdDisplayName') as principal_id_display_name, + json_extract(a.value, '$.justInTimeAccessPolicy') as just_in_time_access_policy +from + azure_lighthouse_definition, + json_each(eligible_authorizations) as a; +``` + +### List plan details for each Lighthouse definition +Get an overview of the plan details for the managed services associated with each Lighthouse definition. This can assist in understanding the service plans and ensuring they align with your management requirements. + +```sql+postgres +select + name, + plan ->> 'name' as plan_name, + plan ->> 'product' as plan_product, + plan ->> 'publisher' as plan_publisher, + plan ->> 'version' as plan_version +from + azure_lighthouse_definition; +``` + +```sql+sqlite +select + name, + json_extract(plan, '$.name') as plan_name, + json_extract(plan, '$.product') as plan_product, + json_extract(plan, '$.publisher') as plan_publisher, + json_extract(plan, '$.version') as plan_version +from + azure_lighthouse_definition; +``` diff --git a/go.mod b/go.mod index 66e6b52a..b94ef675 100644 --- a/go.mod +++ b/go.mod @@ -12,6 +12,7 @@ require ( github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/authorization/armauthorization/v2 v2.2.0 github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice/v4 v4.8.0 github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/dataprotection/armdataprotection v1.0.0 + github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managedservices/armmanagedservices v0.7.0 github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/recoveryservices/armrecoveryservicesbackup/v3 v3.0.0 github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sql/armsql v1.2.0 github.com/Azure/azure-storage-blob-go v0.12.0 diff --git a/go.sum b/go.sum index b1880059..b153081f 100644 --- a/go.sum +++ b/go.sum @@ -207,6 +207,8 @@ github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/dataprotection/armdataprot github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/dataprotection/armdataprotection v1.0.0/go.mod h1:CmZQSRwBPP7KNjDA+PHaoR2m8wgOsbTd9ncqZgSzgHA= github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/internal/v2 v2.0.0 h1:PTFGRSlMKCQelWwxUyYVEUqseBJVemLyqWJjvMyt0do= github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/internal/v2 v2.0.0/go.mod h1:LRr2FzBTQlONPPa5HREE5+RjSCTXl7BwOvYOaWTqCaI= +github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managedservices/armmanagedservices v0.7.0 h1:dwmV8G0tLD17J+LcTirpFmNKvZBLLuErtGR0h6h8n2c= +github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managedservices/armmanagedservices v0.7.0/go.mod h1:UmV8UnyCQ+05EvopWqF6CQsFWI5FWcp/AXGVkJguv9E= github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/recoveryservices/armrecoveryservicesbackup/v3 v3.0.0 h1:BIvscO5ZFKaEHoix9jAV6vbatKLiDNb5pj8XjzQR2g4= github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/recoveryservices/armrecoveryservicesbackup/v3 v3.0.0/go.mod h1:4uHLkZ3JvDvacFcEyB0T/cCeVqlvtHHA7DjvpgvlpdA= github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resources/armresources v1.1.1 h1:7CBQ+Ei8SP2c6ydQTGCCrS35bDxgTMfoP2miAwK++OU=