def delete_event_subscription(self):
print("deleting event subscription")
event_client = EventGridManagementClient(self.credentials,
self.subscription_id)
scope = '/subscriptions/' + self.subscription_id + '/resourceGroups/' + self.test_storage_res_group + '/providers/microsoft.storage/storageaccounts/%s' % self.test_storageaccount_name
event_client.event_subscriptions.delete(
scope, self.event_subscription_name + self.res_suffix)
async def run_example():
start = time.time()
credentials, subscription_id = get_credentials()
resource_client = ResourceManagementClient(credentials, subscription_id)
compute_client = ComputeManagementClient(credentials, subscription_id)
network_client = NetworkManagementClient(credentials, subscription_id)
event_client = EventGridManagementClient(credentials, subscription_id)
resource_client.resource_groups.create_or_update(GROUP_NAME,
{'location': LOCATION})
event_client.topics.create_or_update(GROUP_NAME, TOPIC_NAME, LOCATION)
scope = '/subscriptions/' + subscription_id + '/resourceGroups/' + GROUP_NAME #+'/providers/Microsoft.EventGrid/topics/'+TOPIC_NAME
event_client.event_subscriptions.create_or_update(
scope, SUBSCRIPTION_NAME, {
'destination': {
'endpoint_type':
"EventHub",
'resource_id':
"/subscriptions/e243327e-b18c-4766-8f44-d9a945082e57/resourceGroups/scorianihub/providers/Microsoft.EventHub/namespaces/scorianitestgrid/eventhubs/scorianigridhub"
}
})
# subnet = create_vnet(network_client)
# with concurrent.futures.ThreadPoolExecutor(max_workers=100) as executor:
# loop = asyncio.get_event_loop()
# futures = [
# loop.run_in_executor(
# executor,
# create_vm,
# network_client,
# compute_client,
# subnet
# )
# for i in range(vmnumber)
# ]
# for vm in await asyncio.gather(*futures):
# pass
# sbs = ServiceBusService("scorianitestgrid", shared_access_key_name="RootManageSharedAccessKey", shared_access_key_value="tNkx0EMU4YuB5MAaMlP0PQ1pzO4CTkF8+uzLY2O+96Y=")
# while True:
# print("This prints once a minute.")
# time.sleep(1) # Delay for 1 minute (60 seconds).
end = time.time()
print('\n ' + str(vmnumber) + ' VMs created in ' + stopWatch(end - start))
def main():
SUBSCRIPTION_ID = os.environ.get("SUBSCRIPTION_ID", None)
TIME = str(time.time()).replace('.', '')
GROUP_NAME = "testeventgrid" + TIME
EVENTGRID = "eventgrid" + TIME
LOCATION = 'eastus'
# Create client
# # For other authentication approaches, please see: https://pypi.org/project/azure-identity/
resource_client = ResourceManagementClient(
credential=DefaultAzureCredential(), subscription_id=SUBSCRIPTION_ID)
eventgrid_client = EventGridManagementClient(
credential=DefaultAzureCredential(), subscription_id=SUBSCRIPTION_ID)
# - init depended client -
# - end -
# Create resource group
resource_client.resource_groups.create_or_update(GROUP_NAME,
{"location": LOCATION})
# - init depended resources -
# - end -
# Create eventgrid
eventgrid = eventgrid_client.domains.begin_create_or_update(
GROUP_NAME, EVENTGRID, {
"location": LOCATION
}).result()
print("Create eventgrid:\n{}".format(eventgrid))
# Get eventgrid
eventgrid = eventgrid_client.domains.get(GROUP_NAME, EVENTGRID)
print("Get eventgrid:\n{}".format(eventgrid))
# Update eventgrid
eventgrid = eventgrid_client.domains.begin_update(GROUP_NAME, EVENTGRID, {
"tags": {
"tag1": "value1",
"tag2": "value2"
}
}).result()
print("Update eventgrid:\n{}".format(eventgrid))
# Delete eventgrid
eventgrid_client.domains.begin_delete(GROUP_NAME, EVENTGRID).result()
print("Delete eventgrid.\n")
# Delete Group
resource_client.resource_groups.begin_delete(GROUP_NAME).result()
def GetEventGridTopics(tenantId, subscriptionId, resourceGroup,
gridLocation, clientId, cientSecret, topicNames):
credentials = ServicePrincipalCredentials(client_id=clientId,
secret=cientSecret,
tenant=tenantId)
event_grid_client = EventGridManagementClient(credentials,
subscriptionId)
# list of current topics for this RG
pagedTopics = event_grid_client.topics.list_by_resource_group(
resourceGroup)
returnDict = {}
for topic in topicNames:
print(f"Checking for existence of topic {topic}")
p_topic = None
for paged_topic in pagedTopics:
if topic == paged_topic.name:
p_topic = paged_topic
break
if p_topic == None:
print(f"Topic {topic} does not exist. Creating now...")
topic_result_poller = event_grid_client.topics.create_or_update(
resourceGroup, topic,
Topic(location=gridLocation, tags={'createdBy': 'MCCC'}))
# Blocking call
topic_result = topic_result_poller.result() # type: Topic
print(topic_result)
print(f"Topic {topic} Created ")
else:
print(f"Topic {topic} already exists.")
key = event_grid_client.topics.list_shared_access_keys(
resourceGroup, topic).key1
endpoint = f"{topic}.{gridLocation}-1.eventgrid.azure.net"
key = event_grid_client.topics.list_shared_access_keys(
resourceGroup, topic).key1
rTopic = EventGrid.MCCCTopic(topic, key, endpoint)
returnDict[topic] = rTopic
return returnDict
def add_event_grid(src_account_id: str, resource_group: str, location: str) -> None:
credential = AzureCliCredential()
client = EventGridManagementClient(credential)
base = get_base_event(client, resource_group, location)
event_subscription_info = EventSubscription(
destination=base.destination,
filter=base.filter,
retry_policy=base.retry_policy,
)
topic_id = uuid.uuid5(STORAGE_GUID_NAMESPACE, src_account_id).hex
result = client.event_subscriptions.begin_create_or_update(
src_account_id, "corpus" + topic_id, event_subscription_info
).result()
if result.provisioning_state != "Succeeded":
raise Exception(
"eventgrid subscription failed: %s"
% json.dumps(result.as_dict(), indent=4, sort_keys=True),
)
def remove_eventgrid(self) -> None:
credential = AzureCliCredential()
storage_account_client = StorageManagementClient(
credential, subscription_id=self.get_subscription_id())
src_resource_id = Client.get_storage_account_id(
storage_account_client, self.resource_group, "fuzz")
if not src_resource_id:
return
event_grid_client = EventGridManagementClient(
credential, subscription_id=self.get_subscription_id())
# Event subscription for version up to 5.1.0
old_subscription_name = "onefuzz1"
old_subscription_exists = Client.event_subscription_exists(
event_grid_client, src_resource_id, old_subscription_name)
if old_subscription_exists:
logger.info("removing deprecated event subscription")
event_grid_client.event_subscriptions.begin_delete(
src_resource_id, old_subscription_name).wait()
def create_event_subscription(self):
print("creating event subscription")
event_client = EventGridManagementClient(self.credentials,
self.subscription_id)
scope = '/subscriptions/' + self.subscription_id + '/resourceGroups/' + self.test_storage_res_group + '/providers/microsoft.storage/storageaccounts/%s' % self.test_storageaccount_name
destination = EventHubEventSubscriptionDestination(
resource_id=self.get_event_hub_resource_id())
esfilter = EventSubscriptionFilter(
**{
"subject_begins_with":
"/blobServices/default/containers/%s/" %
self.test_container_name,
"subject_ends_with":
"",
"is_subject_case_sensitive":
False,
"included_event_types": ["Microsoft.Storage.BlobCreated"]
})
event_subscription_info = EventSubscription(destination=destination,
filter=esfilter)
create_resp = event_client.event_subscriptions.create_or_update(
scope, self.event_subscription_name, event_subscription_info)
create_resp.wait()
def run_example():
"""Resource Group management example."""
#
# Create the Resource Manager Client with an Application (service principal) token provider
#
subscription_id = os.environ.get(
'AZURE_SUBSCRIPTION_ID',
'11111111-1111-1111-1111-111111111111') # your Azure Subscription Id
credentials = ServicePrincipalCredentials(
client_id=os.environ['AZURE_CLIENT_ID'],
secret=os.environ['AZURE_CLIENT_SECRET'],
tenant=os.environ['AZURE_TENANT_ID'])
resource_client = ResourceManagementClient(credentials, subscription_id)
event_grid_client = EventGridManagementClient(credentials, subscription_id)
# Create Resource group
print('\nCreating a Resource Group...')
resource_group = resource_client.resource_groups.create_or_update(
GROUP_NAME, {'location': LOCATION})
print_item(resource_group)
# Create EventGrid topic
print('\nCreating an EventGrid topic...')
topic_result_async_poller = event_grid_client.topics.create_or_update(
resource_group.name, TOPIC_NAME,
Topic(location=resource_group.location,
tags={
'key1': 'value1',
'key2': 'value2'
}))
# Blocking call for the Topic to be created
topic = topic_result_async_poller.result() # type: Topic
print_item(topic)
# Get the keys for the topic
print('\nGetting the topic keys...')
keys = event_grid_client.topics.list_shared_access_keys(
resource_group.name, topic.name) # type: TopicSharedAccessKeys
print('The key1 value of topic {} is: {}'.format(topic.name, keys.key1))
# Create an event subscription
print('\nCreating an event subscription')
event_subscription_name = 'EventSubscription1'
destination = WebHookEventSubscriptionDestination(
endpoint_url=ENDPOINT_URL)
filter = EventSubscriptionFilter(
# By default, "All" event types are included
is_subject_case_sensitive=False,
subject_begins_with='',
subject_ends_with='')
event_subscription_info = EventSubscription(destination=destination,
filter=filter)
event_subscription_async_poller = event_grid_client.event_subscriptions.create_or_update(
topic.id,
event_subscription_name,
event_subscription_info,
)
# Blocking call for the EventSubscription to be created
event_subscription = event_subscription_async_poller.result(
) # type: EventSubscription
print_item(event_subscription)
input("Press enter to delete all created resources.")
# Delete the EventSubscription
print('\nDeleting the event subscription')
delete_async_operation = event_grid_client.event_subscriptions.delete(
topic.id, event_subscription_name)
delete_async_operation.wait()
print("\nDeleted: {}".format(event_subscription_name))
# Delete the topic
print('\nDeleting the topic')
delete_async_operation = event_grid_client.topics.delete(
resource_group.name, topic.name)
delete_async_operation.wait()
print("\nDeleted: {}".format(topic.name))
# Delete Resource group and everything in it
print('\nDelete Resource Group')
delete_async_operation = resource_client.resource_groups.delete(GROUP_NAME)
delete_async_operation.wait()
print("\nDeleted: {}".format(GROUP_NAME))
def run_example():
"""Resource Group management example."""
#
# Create the Resource Manager Client with an Application (service principal) token provider
#
subscription_id = os.environ.get(
'AZURE_SUBSCRIPTION_ID',
'11111111-1111-1111-1111-111111111111') # your Azure Subscription Id
credentials = ServicePrincipalCredentials(
client_id=os.environ['AZURE_CLIENT_ID'],
secret=os.environ['AZURE_CLIENT_SECRET'],
tenant=os.environ['AZURE_TENANT_ID'])
resource_client = ResourceManagementClient(credentials, subscription_id)
event_grid_client = EventGridManagementClient(credentials, subscription_id)
# Create Resource group
print('\nCreating a Resource Group...')
resource_group = resource_client.resource_groups.create_or_update(
GROUP_NAME, {'location': LOCATION})
print_item(resource_group)
# Creating an event subscription to storage account {StorageAccountResourceId} with destination as {HybridConnectionResourceId}
print(
'\nCreating an event subscription to storage account {} with destination as {}'
.format(STORAGE_ACOUNT_RESOURCE_ID, QUEUE_NAME))
# Scope could be any ARM resource ID that supports EventGrid
# https://docs.microsoft.com/azure/event-grid/event-sources
scope = "/subscriptions/{}".format(subscription_id)
event_subscription_name = 'EventSubscription1'
destination = StorageQueueEventSubscriptionDestination(
resource_id=STORAGE_ACOUNT_RESOURCE_ID, queue_name=QUEUE_NAME)
filter = EventSubscriptionFilter(
# By default, "All" event types are included
is_subject_case_sensitive=False,
subject_begins_with='',
subject_ends_with='')
event_subscription_info = EventSubscription(destination=destination,
filter=filter)
event_subscription_async_poller = event_grid_client.event_subscriptions.create_or_update(
scope,
event_subscription_name,
event_subscription_info,
)
# Blocking call for the EventSubscription to be created
event_subscription = event_subscription_async_poller.result(
) # type: EventSubscription
print_item(event_subscription)
input("Press enter to delete all created resources.")
# Delete the EventSubscription
print('\nDeleting the event subscription')
delete_async_operation = event_grid_client.event_subscriptions.delete(
scope, event_subscription_name)
delete_async_operation.wait()
print("\nDeleted: {}".format(event_subscription_name))
# Delete Resource group and everything in it
print('\nDelete Resource Group')
delete_async_operation = resource_client.resource_groups.delete(GROUP_NAME)
delete_async_operation.wait()
print("\nDeleted: {}".format(GROUP_NAME))
#!/usr/bin/env python
from tdr.azure import credentials, subscription_id
from azure.mgmt.eventgrid import EventGridManagementClient
eventgrid_mgmt_client = EventGridManagementClient(credentials, subscription_id)
from .eventgrid_mgmt import (
create_eventgrid_topic,
subscribe_http_eventgrid_topic,
send_eventgrid_event,
)
def run_example():
"""Resource Group management example."""
#
# Create the Resource Manager Client with an Application (service principal) token provider
#
subscription_id = os.environ.get(
'AZURE_SUBSCRIPTION_ID',
'11111111-1111-1111-1111-111111111111') # your Azure Subscription Id
credentials = ServicePrincipalCredentials(
client_id=os.environ['AZURE_CLIENT_ID'],
secret=os.environ['AZURE_CLIENT_SECRET'],
tenant=os.environ['AZURE_TENANT_ID'])
resource_client = ResourceManagementClient(credentials, subscription_id)
event_grid_client = EventGridManagementClient(credentials, subscription_id)
# Create Resource group
print('\nCreating a Resource Group...')
resource_group = resource_client.resource_groups.create_or_update(
GROUP_NAME, {'location': LOCATION})
print_item(resource_group)
# Creating an event subscription to storage account {StorageAccountResourceId} with destination as {HybridConnectionResourceId}
print(
'\nCreating an event subscription to storage account {} with destination as {}'
.format(STORAGE_ACOUNT_RESOURCE_ID, HYBRID_CONNECTION_RESOURCE_ID))
event_subscription_name = 'EventSubscription1'
destination = HybridConnectionEventSubscriptionDestination(
resource_id=HYBRID_CONNECTION_RESOURCE_ID)
filter = EventSubscriptionFilter(
included_event_types=['Microsoft.Storage.BlobCreatedEvent'],
is_subject_case_sensitive=False,
subject_begins_with='/blobServices/default/containers/container1',
subject_ends_with='.jpg')
event_subscription_info = EventSubscription(destination=destination,
filter=filter)
event_subscription_async_poller = event_grid_client.event_subscriptions.create_or_update(
STORAGE_ACOUNT_RESOURCE_ID,
event_subscription_name,
event_subscription_info,
)
# Blocking call for the EventSubscription to be created
event_subscription = event_subscription_async_poller.result(
) # type: EventSubscription
print_item(event_subscription)
input("Press enter to delete all created resources.")
# Delete the EventSubscription
print('\nDeleting the event subscription')
delete_async_operation = event_grid_client.event_subscriptions.delete(
STORAGE_ACOUNT_RESOURCE_ID, event_subscription_name)
delete_async_operation.wait()
print("\nDeleted: {}".format(event_subscription_name))
# Delete Resource group and everything in it
print('\nDelete Resource Group')
delete_async_operation = resource_client.resource_groups.delete(GROUP_NAME)
delete_async_operation.wait()
print("\nDeleted: {}".format(GROUP_NAME))
def main():
# # Loading input values
# print("::debug::Loading input values")
azure_credentials = os.environ.get("INPUT_AZURE_CREDENTIALS", default='{}')
resource_group = os.environ.get("INPUT_RESOURCE_GROUP", default="")
pattoken = os.environ.get("INPUT_PATTOKEN", default="")
provider_type = os.environ.get("INPUT_PROVIDER_TYPE", default="")
events_to_subscribe = os.environ.get("INPUT_EVENTS_TO_SUBSCRIBE",
default="")
try:
azure_credentials = json.loads(azure_credentials)
except JSONDecodeError:
print(
"::error::Please paste output of `az ad sp create-for-rbac --name <your-sp-name> --role contributor --scopes /subscriptions/<your-subscriptionId>/resourceGroups/<your-rg> --sdk-auth` as value of secret variable: AZURE_CREDENTIALS"
)
raise AMLConfigurationException(
f"Incorrect or poorly formed output from azure credentials saved in AZURE_CREDENTIALS secret. See setup in https://github.com/Azure/aml-workspace/blob/master/README.md"
)
if not resource_group:
raise AMLConfigurationException(f"A resource group must be provided")
# Checking provided parameters
print("::debug::Checking provided parameters")
required_parameters_provided(
parameters=azure_credentials,
keys=["tenantId", "clientId", "clientSecret"],
message=
"Required parameter(s) not found in your azure credentials saved in AZURE_CREDENTIALS secret for logging in to the workspace. Please provide a value for the following key(s): "
)
# # Loading parameters file
# print("::debug::Loading parameters file")
template_file_file_path = os.path.join("/code", "func_deploy.json")
# Mask values
print("::debug::Masking parameters")
mask_parameter(parameter=azure_credentials.get("tenantId", ""))
mask_parameter(parameter=azure_credentials.get("clientId", ""))
mask_parameter(parameter=azure_credentials.get("clientSecret", ""))
mask_parameter(parameter=azure_credentials.get("subscriptionId", ""))
# Login User on CLI
tenant_id = azure_credentials.get("tenantId", "")
service_principal_id = azure_credentials.get("clientId", "")
service_principal_password = azure_credentials.get("clientSecret", "")
subscriptionId = azure_credentials.get("subscriptionId", "")
credentials = None
try:
credentials = ServicePrincipalCredentials(
client_id=service_principal_id,
secret=service_principal_password,
tenant=tenant_id)
except Exception as ex:
raise CredentialsVerificationError(ex)
####################### Authentication Done ###################################
# repository name
repository_name = os.environ.get("GITHUB_REPOSITORY",
"azureeventgridsample")
functionAppName = repository_name.replace(
"/", "") # create a unique function-AppName
functionAppName = functionAppName.replace("_", "").replace("-", "")[:32]
functionFolder = 'fappdeploy'
functionGitHubURL = "https://github.com/Ayaz43/function_app.git"
functionGitHubBranch = "master"
functionName = "generic_triggers"
patToken = pattoken
parameters = {
'functionAppName': functionAppName,
'functionFolder': functionFolder,
'functionGitHubURL': functionGitHubURL,
'functionGitHubBranch': functionGitHubBranch,
'patToken': patToken,
'ownerName': functionAppName
}
parameters = {k: {'value': v} for k, v in parameters.items()}
client = None
try:
client = ResourceManagementClient(credentials, subscriptionId)
except Exception as ex:
raise ResourceManagementError(ex)
template = None
with open(template_file_file_path, 'r') as template_file_fd:
template = json.load(template_file_fd)
deployment_properties = {
'properties': {
'mode': DeploymentMode.incremental,
'template': template,
'parameters': parameters
}
}
try:
validate = client.deployments.validate(resource_group, "azure-sample",
deployment_properties)
validate.wait()
except Exception as ex:
raise ActionDeploymentError(ex)
try:
deployment_async_operation = client.deployments.create_or_update(
resource_group, 'azure-sample', deployment_properties)
deployment_async_operation.wait()
except Exception as ex:
raise ActionDeploymentError(ex)
deploymemnt_result = deployment_async_operation.result()
# parameters
code = deploymemnt_result.properties.outputs['hostKey']['value']
functionAppName = deploymemnt_result.properties.outputs['functionAppName'][
'value']
function_url = "https://{}.azurewebsites.net/api/{}?code={}&repoName={}".format(
functionAppName, functionName, code, repository_name)
resource_id = "/subscriptions/{}/resourceGroups/{}/providers/{}".format(
subscriptionId, resource_group, provider_type)
event_grid_client = EventGridManagementClient(credentials, subscriptionId)
event_subscription_name = 'EventSubscription1'
destination = WebHookEventSubscriptionDestination(
endpoint_url=function_url)
included_events = get_events_list(events_to_subscribe)
filter = EventSubscriptionFilter(
# By default, "All" event types are included
included_event_types=included_events,
is_subject_case_sensitive=False,
subject_begins_with='',
subject_ends_with='')
event_subscription_info = EventSubscription(destination=destination,
filter=filter)
event_subscription_async_poller = event_grid_client.event_subscriptions.create_or_update(
resource_id,
event_subscription_name,
event_subscription_info,
)
event_subscription = event_subscription_async_poller.result(
) # type: EventSubscription
print(
f"::set-output name=destination_url::{event_subscription.destination.endpoint_base_url}"
)
