Azure Redis Cache Geo-Replication in Public Preview

We are pleased to announce a public preview of the geo-replication functionality in the Azure Redis service. Geo-replication gives you the ability to link Redis caches across different Azure regions to form a primary-replica relationship. It provides an ingredient necessary for any disaster recovery design in your application. Geo-replication preview is available now for all premium Azure Redis caches. At present, we support having one primary cache and one replica in a geo-redundant configuration.

Configuring Azure Redis Caches for Geo-Replication

To setup geo-replication, you need two instances of Azure Redis premium cache belonging to one Azure subscription, one to be used as the primary and the other as the replica. You create the replica cache in exactly the same way that you have created the primary. The replica cache needs to be equal or bigger in size than the primary cache and, additionally, have a matching number of shards if the primary cache is clustered. While there is no requirement for the two caches to be located in different Azure regions, that is the most commonly expected case. If they reside in VNET(s), the caches must be able to reach each other. You can refer to this GitHub document for the current list requirements and restrictions for using geo-replication.

Once you have the Redis caches that you want to use for geo-replication, you can link them together in the Azure management portal. You start by selecting your primary cache. You then find the geo-replication option under the Settings for that cache. By default, when you choose geo-replication, it will show you any replica cache that has been linked to the primary cache. Since we are setting up geo-replication for the first time, no caches are associated yet.

You use “Add cache replication link” to create a uni-directional replicating relationship from the primary cache to the replica. Clicking on that button gives you a list of eligible caches that can be used for geo-replication, grouped by Azure regions. You can switch to a specific Azure region using either the world map or the Location list.

After you choose which cache to be used as the replica, you need to click on the “Link” button to finish the setup.

This will configure the primary cache to replicate data to the replica and disable all other “write” operations to the latter. It takes some time to set up everything and copy existing data in the primary cache. When that whole process is completed, you will see the change in the Azure portal.

Failing over to the replica

The Azure Redis service does not support automatic failover across Azure regions in the first release. Geo-replication is used primarily in a disaster recovery scenario. In such an event, customers will want to bring up the entire application stack in a backup region in a coordinated manner rather than letting individual application components decide when to switch to their backups on their own. This is especially relevant to Redis. One of the key benefits of Redis is being a very low-latency store. If Redis used by an application fails over to a different Azure region but not the compute tier, the added roundtrip time will have a noticeable impact on performance. For this reason, we would like to avoid Redis failing over automatically due to transient availability issues.

Currently, to initiate the failover, you need to unlink the replica cache from the primary in the Azure portal and change the connection end-point in the Redis client from the primary cache to the replica. You will be able to do this using the Azure management SDK’s and command-line tools soon, so that you can script and automate the sequence if needed. When the two caches are disassociated, the replica becomes a regular read-write cache again and accepts requests directly from Redis clients.

Understanding additional costs

There is no extra charge for using the geo-replication functionality in the Azure Redis service. Having said that, there will be additional costs associated with sending network traffic between the two Azure regions should your primary and replica caches be located in different regions. You should be aware of this standard charge for network communication that Azure applies.

We hope that you will find Azure Redis geo-replication useful to your application. If you have any feedback about this new feature, please feel free to reach out to us at AzureCache@microsoft.com.
Quelle: Azure

Mesosphere DCOS, Azure, Docker, VMware and everything between – Security & Docker Engine Installation

In part 2 of this series, we will start to dive into DC/OS 1.9 installation on top of vSphere. Mesosphere offers few ways to deploy a fully working cluster and since I wanted to see how everything is really connected, I have chosen the advanced installation method. We will start with some Linux related adjustments and the Docker engine deployment.

I really like how the DC/OS team organized their online installation guides. It’s clean, pretty comprehensive, and well understood. You basically have 3 local installation methods for “production scale” deployment – GUI, CLI & the Advanced way which was the one I went with.

Although the installation guide is very good, it misses some stuff which is mostly Linux related. In this series, I will try to demystify those, so everything, as the Zohan would say, will be “silky smooth”.

Throughout the deployment process, you will notice that I put VMware snapshots interrupts which will warn you when I’m recommending taking a snapshot on all the VMs, so you will be able to maintain consistency.

Read more about all the details around DC/OS 1.9, Docker and the Security perquisites on top of VMware vSphere in my personal blog.
Quelle: Azure

How we built it: Next Games global online gaming platform on Azure

Today on Microsoft Mechanics, we are joined by the Chief Technology Officer and co-founder of Finnish mobile gaming company Next Games, Kalle Hiitola, for the next episode of "How we built it."

Next Games has built a successful global connected gaming platform on Azure with users spanning 166 countries and growing.

Their popular Walking Dead No Man's Land game is aligned to the popular Walking Dead TV series. The game releases a rapid cadence of new chapters and characters to compliment the release of each new episode.

Built for Cloud

Their Cloud-native approach comprises carefully crafted loosely-coupled core back end services for their Driller TM gaming platform which gives them the flexibility to change every aspect of the mobile games running on their platform on the fly.

These run on a robust infrastructure of Azure services to handle everything from player compute, gaming content updates, all gaming interactions such as in-app purchases, the storing of player states, metadata such as scores, gaming analytics to manage the in-game experience and notifications.

Their Azure-based architecture includes load balancing to support simultaneous gaming sessions and compute instances are designed to be stateless and scale out infinitely based on demand.

Solutions for Gamer Fraud and Content Delivery

Two important areas of innovation include gamer fraud protection and dynamic content delivery.

As Kalle explains, the same logic is run on the client and server enabling fast detection and prevention of fraud if the client tries to write back an invalid value based on the last known player state.

Dynamic content delivery is made possible by publishing video game trailers to Azure Media Services and new gaming content is published via their core gaming services triggering notifications to players.

Join us for the Next Games AMA

To learn more about Next Games online gaming platform on Azure, please check out today's episode.

The Next Games team with Kalle Hiitola, will also be joining our AMA session on the Microsoft Technical Community, July 11th at 9am PDT at http://aka.ms/how-we-built-it-NextGames
Quelle: Azure

Microsoft Cognitive Services hack: Line Messenger

After the devastating earthquake in Japan in 2011, it became apparent that there was a need for a communication platform that would help better connect people in such situations. Out of this need, the Line Messenger platform was launched and has since evolved into a popular social platform with users spread across the globe. The platform also has a well-supported SDK and API, enabling developers to extend their creations to hundreds of millions of users.

We recently worked with the development team at Line in Tokyo, building out several bot related scenarios that use Cognitive Services on the Line Messenger platform. The resulting hacks ranged from bots that detect what’s on your plate, to bots that can recognize a user’s face, and even a bot that helps people learn and practice new languages.

 

The group of around 20 developers had little experience on Azure going in, but within a few hours they were able to develop, host, and launch their Cognitive Service enabled bots. If you’re interested in trying it out, Line have released a Getting Started kit on their Github, and more info can found on the LINE Engineering Blog.

Have a chat with one of their bots!
Quelle: Azure

Bright Cluster Manager now integrates seamlessly with Azure HPC capabilities

One of our key HPC partners, Bright Computing, has just announced the release of Bright Cluster Manager 8.0, the latest version of their flagship HPC cluster management solution. This new version gives customers the ability to extend an on-premises cluster into Azure for added capacity, or to easily build a cluster entirely in Azure.

Martijn de Vries, CTO at Bright Computing, commented about this release:

“We are pleased to offer this new integration to our customers and we are confident that the solution will be very popular with our user base. Cloud bursting from an on-premises cluster to Microsoft Azure offers companies an efficient, cost-effective, secure and flexible way to add additional resources to their HPC infrastructure. Bright's integration with Azure also gives our clients the ability to build an entire off-premises cluster for compute-intensive workloads in the Azure cloud platform.”

The cloud bursting scenario tends to be the one that our customers are interested in exploring first, and this release of Bright Cluster Manager makes it possible to do this effortlessly and within the cluster environment that Bright Computing customers are already familiar with. By bursting to the cloud, customers can continue to use their existing on-premises resources, while taking advantage of the flexibility and the elasticity of Azure to dynamically grow and shrink their HPC clusters.

Similarly, being able to stand up a cluster in the cloud that behaves and feels exactly like the one customers are used to having on premises is a perfect way to readily shift workloads to the cloud, deploy on-demand resources for a special project, or experiment with new technologies.

The cloud really does open many new possibilities, not just of scale, but also for access to resources that might not always be available on premises. With Bright Cluster Manager and Azure, you can utilize the latest InfiniBand network technologies, or run your workload on the most current GPUs, all on demand and paying only for what you use.

If you want to learn more about HPC technologies, and in particular about this new release of Bright Cluster Manager, you can listen to this episode of The Azure Podcast, which features Martijn de Vries, the CTO of Bright Computing.

Additionally, you can visit the Bright Computing website to learn about their HPC solution for Azure, or to arrange a live demo.
Quelle: Azure

Java: Manage Azure Container Service, Cosmos DB, Active Directory Graph and more

We released 1.1 of the Azure Management Libraries for Java. This release adds support for: Cosmos DB Azure Container Service and Registry Active Directory Graph https://github.com/Azure/azure-sdk-for-java Getting started Add the following dependency fragment to your Maven POM file to use 1.1 version of the libraries:<dependency>
<groupId>com.microsoft.azure</groupId>
<artifactId>azure</artifactId>
<version>1.1.0</version>
</dependency>

Create a Cosmos DB with DocumentDB API
You can create a Cosmos DB account by using a define() … create() method chain.DocumentDBAccount documentDBAccount = azure.documentDBs().define(“myDocumentDB”)
.withRegion(Region.US_EAST)
.withNewResourceGroup(rgName)
.withKind(DatabaseAccountKind.GLOBAL_DOCUMENT_DB)
.withSessionConsistency()
.withWriteReplication(Region.US_WEST)
.withReadReplication(Region.US_CENTRAL)
.create();

In addition, you can:

Create Cosmos DB with DocumentDB API and configure for high availability
Create Cosmos DB with DocumentDB API and configure with eventual consistency
Create Cosmos DB with DocumentDB API, configure for high availability and create a firewall to limit access from an approved set of IP addresses
Create Cosmos DB with MongoDB API and get connection string
Create an Azure Container Registry
You can create an Azure Container Registry by using a define() … create() method chain.Registry azureRegistry = azure.containerRegistries().define(“acrdemo”)
.withRegion(Region.US_EAST)
.withNewResourceGroup(rgName)
.withNewStorageAccount(saName)
.withRegistryNameAsAdminUser()
.create();

You can get Azure Container Registry credentials by using listCredentials().RegistryListCredentials acrCredentials = azureRegistry.listCredentials();
Create an Azure Container Service with Kubernetes Orchestration
You can create an Azure Container Service by using a define() … create() method chain.ContainerService azureContainerService = azure.containerServices().define(“myK8S”)
.withRegion(Region.US_EAST)
.withNewResourceGroup(rgName)
.withKubernetesOrchestration()
.withServicePrincipal(servicePrincipalClientId, servicePrincipalSecret)
.withLinux()
.withRootUsername(rootUserName)
.withSshKey(sshKeys.getSshPublicKey())
.withMasterNodeCount(ContainerServiceMasterProfileCount.MIN)
.withMasterLeafDomainLabel(“dns-myK8S”)
.defineAgentPool(“agentpool”)
.withVMCount(1)
.withVMSize(ContainerServiceVMSizeTypes.STANDARD_D1_V2)
.withLeafDomainLabel(“dns-ap-myK8S”)
.attach()
.create();

You can instantiate a Kubernetes client using a community developed Kubernetes client library.KubernetesClient kubernetesClient = new DefaultKubernetesClient(config);
Deploy from Container Registry to Kubernetes in Container Service
You can deploy an image from Azure Container Registry to a Kubernetes cluster using the same community developed Kubernetes client library and an image pull secret associated with the Container Registry.ReplicationController rc = new ReplicationControllerBuilder()
.withNewMetadata()
.withName(“acssample-rc”)
.withNamespace(acsNamespace)
.addToLabels(“acssample-nginx”, “nginx”)
.endMetadata()
.withNewSpec()
.withReplicas(2)
.withNewTemplate()
.withNewMetadata()
.addToLabels(“acssample-nginx”, “nginx”)
.endMetadata()
.withNewSpec()
.addNewImagePullSecret(acsSecretName)
.addNewContainer()
.withName(“acssample-pod-nginx”)
.withImage(“acrdemo.azurecr.io/samples/acssample-nginx”)
.addNewPort()
.withContainerPort(80)
.endPort()
.endContainer()
.endSpec()
.endTemplate()
.endSpec()
.build();

kubernetesClient.replicationControllers().inNamespace(acsNamespace).create(rc);

You can find the full sample code to deploy an image from container registry to Kubernetes in Container ServiceSimilarly, you can deploy an image from Azure Container Registry to Linux containers in App Service.
Create Service Principal with Subscription Access
You can create a service principal and assign it to a subscription with contributor role by using a define() … create() method chain.ServicePrincipal servicePrincipal = authenticated.servicePrincipals().define(“spName”)
.withExistingApplication(activeDirectoryApplication)
// define credentials
.definePasswordCredential(“ServicePrincipalAzureSample”)
.withPasswordValue(“StrongPass!12″)
.attach()
// define certificate credentials
.defineCertificateCredential(“spcert”)
.withAsymmetricX509Certificate()
.withPublicKey(Files.readAllBytes(Paths.get(certificate.getCerPath())))
.withDuration(Duration.standardDays(7))
// export credentials to a file
.withAuthFileToExport(new FileOutputStream(authFilePath))
.withPrivateKeyFile(certificate.getPfxPath())
.withPrivateKeyPassword(certPassword)
.attach()
.withNewRoleInSubscription(role, subscriptionId)
.create();

Similarly, you can:

Manage service principals
Browse graph (users, groups and members) and managing roles
Manage passwords
Try it
You can get more samples from  https://github.com/azure/azure-sdk-for-java#sample-code. Give it a try and let us know what do you think (via e-mail or comments below).
You can find plenty of additional info about Java on Azure at http://azure.com/java.
Quelle: Azure

Azure Media Services announces support for AAD and deprecation of ACS authentication

This month we are announcing the release of support for Azure Active Directory (AAD) authentication in Azure Media Services. Customers of our REST API and .NET client libraries can now use AAD authentication to authorize requests. In addition, we are releasing a new management blade in the Azure Portal to simplify the usage of User and Service Principal authentication with AAD. With the release of this update to our REST API, we are now able to provide the same role-based access management (RBAC) as provided by the Azure Resource Management (ARM) service. By moving to AAD authentication you will also now be able to track and audit all changes made by specific users or an application connected to your Media Services account. The new Azure Media REST API requires that the user or application making REST API requests must have either contributor or owner level access to the resources it is attempting to manage. More details on how role-based access control works for Azure resources is available at Azure Role-based Access Control. IMPORTANT! 12-month deprecation notice of ACS authentication support in Azure Media Services Because Azure Active Directory provides powerful role-based access control features and support for more fine-grained access to resources in your account compared to the ACS token authentication model (“account keys”), we strongly recommend that you update your code and migrate from ACS to AAD-based authentication by June 22, 2018. Also, a key reason for the rapid migration is the upcoming announced deprecation of the ACS key based authentication system. What does this mean for you? Microsoft Azure Media Services will end support for Microsoft Azure Access Control Service (ACS)-based authentication on June 22, 2018. To provide customers sufficient time to update their application code, we are providing 12 months’ notice to manage the necessary transition. What actions should you take? We recommend that you take the following actions prior to June 22, 2018 to ensure that your applications continue to work as expected: Update the code for your applications authored for Media Services. Migrate from ACS-based authentication. Begin using AAD-based authentication. Mitigation steps must be taken on or before June 22, 2018 to ensure your applications authored for Media Services using ACS authentication tokens will continue to function as expected without failures in production. Please review each of the new authentication scenarios below closely and take the appropriate action to update to using AAD authentication in your source code. The Azure Media Services REST API supports authentication for both interactive users and web API, middle-tier, or daemon applications. The following sections provide details on how to use AAD authentication when working directly with the REST API or through the .NET client library. User Authentication with AAD in Media Services If you are looking to build a management application for your Azure Media Services account like the Azure Media Services Explorer tool, you can simply login with a User’s credentials that has been granted access to the Media Services Resource in the portal via the Access Control (IAM) blade. This type of solution is very useful when you want human interaction with the service that fits one of the following scenarios: Monitoring dashboard for your Encoding jobs Monitoring dashboard for your Live Streams Management application for desktop or mobile users to administer resources in a Media services account. A native application would first acquire an access token from Azure Active Directory and then use that access token to make all REST API calls. The following diagram shows a typical interactive application authentication flow. For a RESTAPI request to succeed, the calling user must be a “Contributor” or “Owner” of the Azure Media Services account it is trying to access. Unauthorized requests would fail with status code 401. If you see this failure, please double check that you have configured your user as “Contributor” or “Owner” on the Media Services account. You can check this through the Azure portal by searching for your media account and clicking on “Access control” tab. Users of the .NET client SDK for Media Services must upgrade to the latest version on Nuget (windowsazure.mediaservices version 4.0.0.4 or greater) to use AAD authentication for communicating with REST requests. The following example shows the differences between how to authenticate with the .NET client SDK previously using ACS and the new way that uses AAD credentials. NOTE: Applications will also need to update their references to include a new assembly “Microsoft.WindowsAzure.MediaServices.Client.Common.Authentication.dll” and add references to that namespace as well as reference to the “Microsoft.IdentityModel.Clients.ActiveDirectory” assembly to get access to the ITokenProvider interface. For more information and a detailed sample on using the .NET SDK with AAD see this overview and the available environment settings and constants.   DEPRECATED method of authenticating using ACS credentials // Create and cache Media Services credentials in a static class variable.
_cachedCredentials = new MediaServicesCredentials(
_mediaServicesAccountName,
_mediaServicesAccountKey,
“urn:windowsazuremediaservices”,
“https://wamsprodglobal001acs.accesscontrol.windows.net”);

// Used the cached credentials to create CloudMediaContext.
var mediaContext = new CloudMediaContext(_cachedCredentials);
mediaContext.Assets.FirstOrDefault();
New method of authenticating using AAD credentials and User authenticationvar tokenCredentials = new AzureAdTokenCredentials(“{YOUR AAD TENANT DOMAIN HERE}”, AzureEnvironments.AzureCloudEnvironment);
var tokenProvider = new AzureAdTokenProvider(tokenCredentials);
var mediaContext = new CloudMediaContext(new Uri(“YOUR REST API ENDPOINT HERE”), tokenProvider);
mediaContext.Assets.FirstOrDefault() // This would return a 401 unauthorized if you are not set up as an authorized user

The “AzureEnvironments.AzureCloudEnvironment” constant is a helper in the .NET SDK to get the right environment variable settings for a public Azure Data Center. It contains pre-defined environment settings for accessing Media Services in the public data centers only. For sovereign or government cloud regions, you can use the ” AzureChinaCloudEnvironment”, “AzureUsGovernmentEnvrionment”, or “AzureGermanCloudEnvironment” respectively.
A lot of the details regarding acquiring an AAD access token has been wrapped and simplified for you in the AzureAdTokenProvider and AzureAdTokenCredentials classes. For example, you do not need to provide the AAD authority, Media services Resource URI or native AAD application details. These are well known values that are already configured by the AAD access token provider class. If you are not using our .NET client SDK, it is recommended to use the ADAL Library to simplify the creation of the access token request using these parameters. The following values are used by default in the AzureAdTokenProvider and AzureAdTokenCredentials classes.
You also have the option of replacing the default implementation of the AzureAdTokenProvider with your own implementation.
AAD Service Principal Authentication in Media Services
For non-human interaction through daemon services, Web APIs, Consumer (mobile or desktop), and Web application, where interactive login or direct user management/monitoring of resources in the Media Services account is not required, you will need to first create an Azure Active Directory application in its own tenant.
Once it is created, you will have to give this application “Contributor” or “Owner” level access to the Media Services account in the Access Control (IAM) blade. Both steps can easily be done through the Azure Portal or through the Azure CLI, or PowerShell script. Note that for AAD resources, “Contributor” has the same access to the resource as “Owner” but only the “Owner” role can grant access to other users. Currently this version of the Media Services REST API does not provide RBAC at the entity level, but that is something we have on the roadmap for our future API update in the Fall. We have also provided the new “API Access” blade in your Media Services account to make it easy to generate the required application or select from an existing one.  If you would like to use x509 certificates instead or ClientID and ClientKey, you can reference the documentation for details on how to configure the SDK
The following examples show how a daemon application may use AAD web application credentials to authenticate requests with the REST service.

Deprecated way of authenticating using ACS credentials // Create and cache Media Services credentials in a static class variable.
_cachedCredentials = new MediaServicesCredentials(
_mediaServicesAccountName,
_mediaServicesAccountKey,
“urn:windowsazuremediaservices”,
“https://wamsprodglobal001acs.accesscontrol.windows.net”);

// Used the cached credentials to create CloudMediaContext.
var mediaContext = new CloudMediaContext(_cachedCredentials);

New way of authenticating with an AAD Service Principal and client symmetric keyvar tokenCredentials = new AzureAdTokenCredentials(“{YOUR AAD TENANT DOMAIN HERE}”, new AzureAdClientSymmetricKey(“{YOUR CLIENT ID HERE}”, “{YOUR CLIENT SECRET}”), AzureEnvironments.AzureCloudEnvironment);
var tokenProvider = new AzureAdTokenProvider(tokenCredentials);

var mediaContext = new CloudMediaContext(_mediaServicesApiServerUri, tokenProvider);mediaContext.Assets.FirstOrDefault();

Making it easy to get started with the new API Access Blade for Media Services
Azure Active Directory authentication could be complex for users unfamiliar with the details of AAD, so we wanted to make it very easy to get started with very little knowledge of AAD. For that reason, we are introducing a new “API Access” blade for Media Services accounts in the portal that will replace the previous ACS “Account keys” blade. We are also disabling the ability to rotate the ACS keys to promote users to update their code and move to AAD support.
The new API Access blade makes the process of connecting to Azure Media Services with AAD much simpler. When you first select the API Access blade, you will be presented with a choice of using either user authentication for human interactive management applications, or creating a Service Principal and AAD application for non-human interaction with the Media Services API.
 
When selecting the user based authentication option, you will see a new panel that contains all the Active Directory information needed to authenticate with the API. This includes the API endpoint that you need to call, along with the ClientID, Domain, and Resource.
 
For Service Principal authentication, you will see additional values and the ability to select from an existing AAD Application or create a new one directly in the panel.

When the Service Principal blade opens, it selects the first AAD application that meets the following criteria:

It is a registered AAD application
It has “Contributor” or “Owner” RBAC permissions on the account
After creating or selecting an AAD app, you will be able to create and copy a Key (Client Secret) and copy the Client ID (Application ID) which are required to get the access token in this scenario. In the blade, you can choose to “Create New” AAD Application, or select from an Existing one in your Subscription.  When selecting an existing one, you will see a new blade listing your existing applications to choose from.

Once you select from an existing application or create a new one, you will see additional buttons to “Manage Permissions” or “Manage Application”.  You can use these settings to open the AAD application management blade directly to perform management tasks such as changing keys or reply URL, or customizing the applications manifest.
Clicking on the Manage Application button will bring up the AAD application management blade which allow you to create Keys for use with the API using this application.

If you do not have permissions to create AAD apps in your Domain, the AAD app controls of the blade are not shown and a warning message is shown instead.
  Next Steps and Actions for Media Services Customers
We are very excited to be making the transition from the older ACS key based authentication to the more secure, flexible, and role-based Azure Active Directory service. All Azure Media Services customers should begin immediately to migrate to use the new AAD based authentication model by downloading the latest .NET SDK, or updating their existing REST based API calls.
In addition, we are working on a new version of our REST APIs with support for more client SDK languages with AAD authentication. More details on that updated API will come in a later blog post.
The key actions you should be taking today:

If you are using .NET, update to the latest SDK and migrate to AAD authentication.
Plan early for the deprecation of ACS authentication support in Media Services API. The older ACS authentication support will be shutting off officially on June 22, 2018.
Note on Java SDK and Open Source and Community driven client SDKs
If you are currently using the Java SDK or one of the many community or open source generated client SDKs for Media Services, you have a couple of options at this time.  The existing Java SDK for Media Services will be updated in the coming months to support AAD authentication for customers to immediately begin migration to.  For the open source libraries, since these are not supported directly by the Media Services team, you would need to work with the community SDK developer to prioritize updating the SDK to support AAD for your scenario. We also recommend that you stick with the community SDK a little longer, as we reach out to the developers and work with them to update their libraries.  In addition, we are working hard on an updated REST API (v3) that is coming out later this Fall with support for AutoRest generated client SDKs across PHP, Java, Python, and more which will support AAD authentication. We will be following up with more blog posts on migrating to the new v3 API and client SDKs when they are ready for preview.
Resources and Additional Documentation
For more details, sample code and specific scenario documentation, please refer to the following articles:

Use AAD auth to access the API
Use the Azure Portal to Manage AAD Auth
Access the Media Services API with .NET and AAD
Use the Azure CLI 2.0 to create and configure an AAD app
Use PowerShell to create and configure an AAD app 
Contact Us with Questions
As always, if you have any questions, comments, or feedback, please post a message or question to our MSDN Forum or use Stack Overflow. For direct support, please submit a support request through the Azure Portal. We are also available on Twitter via @MSFTAzureMedia.
Quelle: Azure

Building an Azure Analysis Services Model for Azure Blobs — Part 3

The third and final part of the article series “Building an Azure Analysis Services Model on Top of Azure Blob Storage” has been published on the Analysis Services team blog. It shows that an Azure Analysis Services S9 server can successfully ingest more than 1,000 source files in a 1-terabyte TPC-DS data set stored in Azure Blob Storage in less than 12 hours. Among other things, Part 3 demonstrates how to analyze the memory consumption of the model and how to optimize model size and processing times. This part also discusses the advantages of more sophisticated data sources, such as Azure SQL Data Warehouse, over Azure Blob Storage for reducing the data volume that must be transferred to Azure Analysis Services for processing. Thanks to the modern Get Data experience, you can build a flexible data import pipeline directly in a Tabular model and import even very large data sets with reasonable processing times.

 

Read the full article “Building an Azure Analysis Services Model on Top of Azure Blob Storage”.
Quelle: Azure