Forem: Thiago Custódio

Azure Landing Zones and CAF: A Strategic Roadmap to Cloud Success

Thiago Custódio — Thu, 14 Mar 2024 15:01:22 +0000

In the past, I had heard a lot about the Cloud Adoption Framework and its benefits. Then, people began promoting Azure Landing Zones, but the relationship between them wasn't clear to me.

The Cloud Adoption Framework (CAF) is a comprehensive playbook designed to facilitate a seamless transition to the cloud. It encompasses everything from initial planning and readiness assessment to the actual migration, security, governance, and ongoing optimization.

Landing Zones are pre-configured environments that serve as a secure foundation for cloud deployments. The principles of the CAF are embodied in Azure Landing Zones, providing a scalable, compliant, and secure starting point for your cloud journey.

In summary, Landing Zones and the Cloud Adoption Framework are complementary, with the CAF providing the comprehensive strategy and best practices for cloud adoption, and Landing Zones offering the practical, technical foundation that aligns with the CAF's guidelines.

Seeking Expertise? If you're looking for guidance or wish to deepen your understanding of Azure Landing Zones and the CAF, let's connect. Together, we can explore how these powerful tools can be tailored to fit your organization's unique needs, driving your cloud adoption towards success with precision and confidence.

azure #cloud #microsoft #mvp #CloudWithThiago #DigitalTransformation #CloudAdoptionFramework #landingzone #AzureLandingZone

The 5 Disciplines of Cloud Governance

Thiago Custódio — Fri, 08 Mar 2024 20:14:16 +0000

Governance refers to the mechanisms, processes, and relations by which an organization is controlled and directed. It encapsulates the framework within which objectives are set and the means of attaining those objectives and monitoring performance are determined.

Why Establish Governance Over Your Cloud Environment?
In the rapidly evolving landscape of cloud technology, establishing a governance framework is imperative. It ensures that the use of cloud services aligns with an organization's strategic goals, complies with regulatory requirements, and optimizes resource utilization.

Without effective governance, organizations may face uncontrolled cloud costs, security vulnerabilities, inconsistent resource management, and challenges in scaling operations efficiently. Governance provides a structured approach to managing these complexities, ensuring that cloud services contribute positively to the organizational objectives.

Key Disciplines of Cloud Governance:

Cost Management: Cost management within cloud governance involves monitoring and controlling spending to avoid overutilization or underutilization of resources. This discipline ensures that organizations can forecast their spending accurately and allocate their cloud budget efficiently, maximizing the return on investment in cloud services.
Security Baseline: Establishing a security baseline is critical in defining the minimum-security standards for protecting cloud resources. This includes implementing policies for access control, data encryption, and threat detection to mitigate risks and comply with data protection regulations.
Resource Consistency: Resource consistency aims to standardize the configuration and management of cloud resources. By ensuring a uniform approach across the cloud environment, organizations can streamline operations, reduce errors, and improve the reliability of their services.
Identity Baseline: The identity baseline discipline focuses on managing user identities and access privileges. It is essential for defining who can access specific cloud resources and what actions they are authorized to perform, thereby safeguarding sensitive data and systems from unauthorized use.
Deployment Acceleration: Deployment acceleration refers to the practices and tools that enable organizations to launch and update cloud services more rapidly and efficiently. This discipline supports agility and innovation by reducing the time to market for new features and applications.

Establishing cloud governance is a critical strategic framework that enables organizations to leverage cloud computing effectively and responsibly. By adhering to these disciplines, organizations can achieve operational excellence, enhance security, and drive innovation in their cloud environments.

Quick tip on Azure Cosmos DB indexes

Thiago Custódio — Wed, 21 Feb 2024 16:30:19 +0000

"Don't accept the defaults." - Abel Wang

Most people aren't aware, but by default, every property in your document stored in Cosmos DB is indexed. While this is fantastic for performance, optimizing query speed across your data, it can become costly if you're dealing with a large amount of data.

This default behavior, though beneficial in many scenarios, may not suit every use case, especially when budget constraints are tight, or specific data doesn't require fast query access.

The good news is that Azure Cosmos DB offers the flexibility to customize this behavior. You have the option to disable indexing on certain properties or to create custom indexes that better fit your application's needs, potentially saving costs without compromising on performance where it matters most.

For those looking to dive deeper into how to fine-tune your Azure Cosmos DB setup, Microsoft Learn offers a comprehensive guide on customizing indexes for the SQL API. It covers everything from the basics of indexing to advanced techniques for optimizing your data access patterns.

Learn how to optimize your Azure Cosmos DB indexes: Customize Indexes in Azure Cosmos DB for the SQL API.

Taking control of your database's indexing strategy can lead to significant performance improvements and cost savings. Don't settle for the defaults; tailor your Azure Cosmos DB to meet your specific needs.

azure #cosmosDb #microsoft #cloud #CloudWithThiago #AzureTips

Quick tip on Azure Cosmos DB indexes

Thiago Custódio — Wed, 21 Feb 2024 16:30:17 +0000

"Don't accept the defaults." - Abel Wang

This default behavior, though beneficial in many scenarios, may not suit every use case, especially when budget constraints are tight, or specific data doesn't require fast query access.

Learn how to optimize your Azure Cosmos DB indexes: Customize Indexes in Azure Cosmos DB for the SQL API.

azure #cosmosDb #microsoft #cloud #CloudWithThiago #AzureTips

How Azure Container Apps Simplify the Cloud Deployment Process

Thiago Custódio — Mon, 12 Feb 2024 17:25:17 +0000

In the recent past, while supporting one of our clients through their digital transformation journey, they shared the decision to adopt Kubernetes as their preferred platform for container orchestration. During the assessment phase, where we gather more information about the client, the project, and internal processes, several questions emerged:

How familiar are you with the Kubernetes ecosystem and its components?
Have you faced any challenges in configuring networking between microservices within Kubernetes? If so, how have you addressed them?
How do you manage the lifecycle of your applications within Kubernetes, from deployment to scaling to updates?

It became clear to me that Kubernetes was their goal for a container orchestration platform, but at that moment, they were not ready for it. More than that, they were unaware of the challenges and the processes they would need to adopt in order to succeed (I will write more about this in another post).

Continue reading on: https://lnkd.in/ge8F8UHQ

My highlights from Microsoft Build 2023 for Azure Functions

Thiago Custódio — Wed, 24 May 2023 16:54:43 +0000

Microsoft Build 2023 brought exciting new developments for Azure Functions, empowering developers to create powerful serverless applications with ease. In this blog post, we will dive into the top three highlights from the event that will transform the way you leverage Azure Functions. From enhanced data integration to automated triggers and a revolutionary storage backend, these updates are set to take your applications to new heights.

Azure SQL Bindings: Seamless Integration for Data Access and Manipulation

Azure SQL bindings for Azure Functions have officially become generally available, marking a significant milestone in the evolution of serverless computing. This development enables effortless integration between Azure SQL and your Functions, allowing for seamless data access and manipulation. With this feature, you can now build applications that interact with Azure SQL databases without the need for complex configurations or extensive coding efforts. By simplifying the data integration process, Azure Functions empower developers to focus on application logic and deliver robust solutions more efficiently.

Azure Cache for Redis Trigger: Automate Actions with Real-time Redis Cache Monitoring

Introducing the Azure Cache for Redis trigger, a game-changer in the world of serverless computing. This powerful feature allows developers to react to changes in their Redis cache and trigger Azure Functions accordingly. Gone are the days of manual monitoring and continuous polling. With this trigger, you can automate actions based on real-time updates in your Redis cache, significantly improving efficiency and responsiveness. Whether it's updating related data, processing notifications, or executing custom business logic, the Azure Cache for Redis trigger simplifies the development process by providing a seamless integration point between your Redis cache and Azure Functions.

Microsoft Netherite & MSSQL: Revolutionary Storage Backend for Durable Functions

Hold your breath for the most revolutionary update yet! Microsoft Build 2023 introduced a cutting-edge storage backend for Durable Functions called Microsoft Netherite & MSSQL. This breakthrough technology takes Durable Functions to the next level, providing enhanced performance and scalability. With Netherite & MSSQL, you can achieve unprecedented levels of efficiency when managing long-running workflows and stateful orchestrations. Leveraging the power of Microsoft SQL Server, this storage backend offers robust durability, fault tolerance, and global scalability, ensuring your Durable Functions can handle the most demanding workloads with ease.

The highlights from Microsoft Build 2023 for Azure Functions showcased the continuous innovation happening in the serverless computing space. The availability of Azure SQL bindings simplifies data integration, the Azure Cache for Redis trigger automates actions with real-time updates, and the introduction of Microsoft Netherite & MSSQL brings a revolutionary storage backend to Durable Functions. These updates empower developers to build more efficient, scalable, and responsive applications, ultimately driving greater value and delivering exceptional user experiences.

Stay tuned for more exciting developments as Azure Functions continues to evolve and revolutionize the world of serverless computing.

For more information: https://techcommunity.microsoft.com/t5/apps-on-azure-blog/azure-functions-may-update-for-microsoft-build/ba-p/3827388

The Well Architected Framework

Thiago Custódio — Thu, 15 Dec 2022 14:17:31 +0000

The Well Architected Framework is a set of guidelines and best practices for building good cloud computing applications.

It can help you make sure your applications are reliable, secure, efficient, and cost-effective. Some of the benefits of using the Well Architected Framework include:

Better performance: The framework can help you design your applications so they run faster and more smoothly.
Improved security: The framework includes guidelines for protecting your applications from cyber threats and unauthorized access.
Reduced costs: The framework can help you save money by making sure you only use the resources you need, and by helping you avoid costly mistakes.
Greater scalability: The framework can help you design your applications so they can easily handle increases in traffic or data without breaking.

Overall, the Well Architected Framework is a helpful tool for anyone who wants to build high-quality, successful cloud computing applications.

Do you want to learn more about it?

https://learn.microsoft.com/en-us/azure/architecture/framework/

azure #microsoft #cloud #cloudcomputing #wellArchitectedFramework

Rompendo barreiras com tradutor multi idiomas

Thiago Custódio — Sat, 16 Nov 2019 19:28:49 +0000

Outro dia, esse tweet apareceu na minha linha do tempo do Twitter:

Meio extremo, mas eu entendi o ponto de vista dele, apesar de acreditar que as pessoas são livres para postar o que quiserem e no idioma que desejam. Como você pode ver, muitas pessoas responderam a esse tweet e ele se tornou um tópico interessante.

Às vezes, o que você deseja compartilhar é relevante para parte do seu público, outras vezes pode ser útil para várias culturas e, como o inglês é o idioma universal, acredito que devemos compartilhar o conteúdo em inglês.

"Mas eu não falo inglês, o que posso fazer?"

Acredite ou não, existe um site que pode traduzir o que você deseja para vários idiomas e é gratuito. Tudo o que você precisa fazer é acessar https://translate.google.com e selecionar os idiomas de origem e de destino, escrever o texto que deseja traduzir e pressionar a tecla Enter.

WOW!

História engraçada: meu amigo Rodrigo Kono viajou para o Japão e passou duas horas no aeroporto tentando obter ajuda para ir ao hotel. Ele me enviou um áudio dizendo esse "problema" e lembrei-o do aplicativo tradutor do Google, que possui um recurso em que você pode usar a câmera do seu telefone para traduzir um texto em tempo real. Ele conseguiu ir para o hotel e dias depois, retornar ao Brasil e o dia foi salvo graças ao seu antigo colega de quarto aqui.

Mas e se você não é um fã do Google ou se deseja incluir recursos de tradução em seus aplicativos? Você pode consumir modelos pré-treinados de IA por meio de APIs REST e obter o mesmo resultado.

Em 2016, enquanto eu morava na Nova Zelândia, conheci um cara que começou sua própria empresa depois que seu aplicativo foi apresentado no Tech Crunch. Basicamente, ele criou um aplicativo disruptivo de tradução de 1-N idiomas. Você pode ler o artigo completo aqui: https://techcrunch.com/2016/04/20/miss-d-is-a-dictionary-app-for-the-linguistically-curious/

Codificando seu próprio mecanismo de tradução usando o Cognitive Services + Azure Functions + Azure Storage

A primeira coisa que precisamos fazer é acessar o Portal do Azure e criar um novo "Texto do Tradutor" na sua Assinatura do Azure:

Em seguida, precisamos escolher a camada de preços e escolher um nome para o serviço:

Agora, vamos criar um projeto do Azure Functions usando o Visual Studio:

Depois disso, vamos especificar que nossa função será acionada sempre que um novo blob for carregado na nossa conta de armazenamento:

Em seguida, precisamos instalar um pacote nuget para simplificar a requisição http ao Serviço Cognitivo, que traduzirá o texto:

using System;
using System.IO;
using Microsoft.Azure.WebJobs;
using Microsoft.Extensions.Logging;
using CognitiveServices.Translator;
using CognitiveServices.Translator.Translate;
using Microsoft.Azure.Storage.Blob;
using Microsoft.Azure.Storage.Auth;

namespace MultiLanguageTranslator
{
    public class Function1
    {
        [FunctionName("Function1")]
        public static void Run([BlobTrigger("english/{name}", Connection = "StorageConnectionString")]Stream myBlob, string name, ILogger log)
        {
            log.LogInformation($"C# Blob trigger function Processed blob\n Name:{name} \n Size: {myBlob.Length} Bytes");

            var translateClient = new TranslateClient(new CognitiveServices.Translator.Configuration.CognitiveServicesConfig
            {
                Name = Environment.GetEnvironmentVariable("CognitiveServicesName"),
                SubscriptionKey = Environment.GetEnvironmentVariable("CognitiveServicesKey"),
                SubscriptionKeyAlternate = Environment.GetEnvironmentVariable("CognitiveServicesKey"),
            });

            using (var sr = new StreamReader(myBlob))
            {
                var fullContent = sr.ReadToEnd();
                var desiredLanguages = new string[] { "de", "es", "fr", "pt",  "it", "nl" };

                var responses = translateClient.Translate(new RequestContent(fullContent), new RequestParameter
                {
                    From = "en",
                    To = desiredLanguages,
                    IncludeAlignment = true
                });

                var storageAccountName = Environment.GetEnvironmentVariable("StorageAccountName");
                var storageAccountKey = Environment.GetEnvironmentVariable("StorageAccountKey");
                var storageAccountEndpoint = Environment.GetEnvironmentVariable("StorageEndpoint");

                var storageCredentials = new StorageCredentials(accountName: storageAccountName, keyValue: storageAccountKey);
                var blobClient = new CloudBlobClient(new Uri(storageAccountEndpoint), storageCredentials);

                var container = blobClient.GetContainerReference("translations");
                container.CreateIfNotExists();

                foreach (var response in responses)
                {
                    foreach(var translation in response.Translations)
                    {
                        var blob = container.GetBlockBlobReference($"{translation.To}.txt");
                        blob.UploadText(translation.Text);
                    }
                }
            }
        }
    }
}

Em resumo, o Azure Functions obterá o conteúdo do texto original que será carregado na Conta de Armazenamento definida por meio da string de conexão StorageConnectionString. O conteúdo pode ser acessado através da variável myBlob.
Estamos lendo o conteúdo usando a classe StreamReader e, em seguida, criando um array de strings com os idiomas que queremos traduzir a partir do conteúdo original em inglês.

Em seguida, obtemos algumas variáveis de ambiente (definiremos no Portal do Azure quando criarmos a Azure Function) e finalmente, vamos acessar a conta de armazenamento mais uma vez para armazenar o texto traduzido.

Hospedando o código criado

Primeiro, vamos criar a conta de armazenamento:

Em seguida, vamos criar a Azure Function e obter o perfil de publicação para simplificar nosso processo de publicação:

Depois de pronto, podemos obter o perfil de publicação na aba Visão geral:

Agora, vamos usar nosso Visual Studio para publicar nosso código:

Por fim, vamos criar as variáveis de ambiente clicando no link de configuração também fica na aba Visão geral:

Vamos ver tudo em ação:

A lista completa de idiomas suportados pode ser encontrada aqui: https://docs.microsoft.com/en-us/azure/cognitive-services/translator/language-support

Breaking the barriers with a multi language translator

Thiago Custódio — Sat, 16 Nov 2019 19:09:25 +0000

Another day this tweet appeared on my Twitter timeline:

English: "IT Brazilians professionals who lives in Brazil, with no real relevance overseas, tweeting in English, until when?
Our country needs good professionals, and needs to include hundred thousands of people in IT, and most of them don't speak English. Be better than that, share in Portuguese.

Kind of extreme, but I understood his point even though I believe people is free to post whatever they want and in the language they want. As you can see, many people had replied to this tweet and it became an interesting thread.

Sometimes what you want to share is relevant to part of your audience, other times it can be useful to multiple cultures and as English is the universal language, I do believe we should share the content in English.

"But I don't speak English, what can I do?"

Believe or not, there's a website who can translate what you want to multiple languages, and it's free. All you need to do is go to https://translate.google.com and select the source and target languages, write the text you want to translate and hit the enter key.

WOW!

Funny story: my friend Rodrigo Kono traveled to Japan and spent two hours at the airport trying to get help to go to his hotel. He sent me an audio telling me this "problem" and I reminded him about Google translator app, which has a feature where you can use the camera of your phone to translate a text in real time. He managed to go to his hotel and days later, return to Brazil and the day was salved thanks to his former roommate over here.

But what if you're not a Google fan or if you want to include translation features in your applications? You can consume AI pre-trained models through REST API's and achieve the same result.

In 2016 while I was living in New Zealand, I've met a guy who started his own company after his app got featured on Tech Crunch. Basically he created an app and disrupted the traditional 1-1 language translation. You can read the full article in here: https://techcrunch.com/2016/04/20/miss-d-is-a-dictionary-app-for-the-linguistically-curious/

Coding your own translation mechanism using Cognitive Services + Azure

Functions + Azure Storage

The first thing we need to do is access Azure Portal and create a new "Translator Text" in your Azure Subscription:

Then we need to choose the pricing tier and choose a name for the service

Now, let's create an Azure Functions project using Visual Studio:

After that, let's specify that our function will be triggered whenever a new blob was uploaded to our Storage Account:

Next we need to install a nuget package to simplify the http request against the Cognitive Service which will translate out text:

using System;
using System.IO;
using Microsoft.Azure.WebJobs;
using Microsoft.Extensions.Logging;
using CognitiveServices.Translator;
using CognitiveServices.Translator.Translate;
using Microsoft.Azure.Storage.Blob;
using Microsoft.Azure.Storage.Auth;

namespace MultiLanguageTranslator
{
    public class Function1
    {
        [FunctionName("Function1")]
        public static void Run([BlobTrigger("english/{name}", Connection = "StorageConnectionString")]Stream myBlob, string name, ILogger log)
        {
            log.LogInformation($"C# Blob trigger function Processed blob\n Name:{name} \n Size: {myBlob.Length} Bytes");

            var translateClient = new TranslateClient(new CognitiveServices.Translator.Configuration.CognitiveServicesConfig
            {
                Name = Environment.GetEnvironmentVariable("CognitiveServicesName"),
                SubscriptionKey = Environment.GetEnvironmentVariable("CognitiveServicesKey"),
                SubscriptionKeyAlternate = Environment.GetEnvironmentVariable("CognitiveServicesKey"),
            });

            using (var sr = new StreamReader(myBlob))
            {
                var fullContent = sr.ReadToEnd();
                var desiredLanguages = new string[] { "de", "es", "fr", "pt",  "it", "nl" };

                var responses = translateClient.Translate(new RequestContent(fullContent), new RequestParameter
                {
                    From = "en",
                    To = desiredLanguages,
                    IncludeAlignment = true
                });

                var storageAccountName = Environment.GetEnvironmentVariable("StorageAccountName");
                var storageAccountKey = Environment.GetEnvironmentVariable("StorageAccountKey");
                var storageAccountEndpoint = Environment.GetEnvironmentVariable("StorageEndpoint");

                var storageCredentials = new StorageCredentials(accountName: storageAccountName, keyValue: storageAccountKey);
                var blobClient = new CloudBlobClient(new Uri(storageAccountEndpoint), storageCredentials);

                var container = blobClient.GetContainerReference("translations");
                container.CreateIfNotExists();

                foreach (var response in responses)
                {
                    foreach(var translation in response.Translations)
                    {
                        var blob = container.GetBlockBlobReference($"{translation.To}.txt");
                        blob.UploadText(translation.Text);
                    }
                }
            }
        }
    }
}

In summary, Azure Functions will get the content of the original text that will upload into the Storage Account defined through the connection string StorageConnectionString. The content can be accessed through myBlob variable.
We're reading the content using the StreamReader class, then creating a string array with the languages we want to translate from the original English content.

Then, we getting some environment variables (we'll define on Azure Portal when we create the Azure Functions), and lastly we're accessing the storage account once again, but this time to store the translated text.

Hosting the created code

First, let's create the storage account:

Then's let's create the azure functions and get the publish profile to simplify our deploy process:

After it's ready, we can get the publish profile through the overview tab:

Now, let's use our Visual Studio to publish our code:

Lastly let's create the environment variables clicking on the configuration link also from the Overview Tab:

Let's see everything in action:

The full language support can be found in here: https://docs.microsoft.com/en-us/azure/cognitive-services/translator/language-support

Implementing a Serverless Saga Orchestrator

Thiago Custódio — Fri, 13 Sep 2019 00:34:51 +0000

This article is part of #ServerlessSeptember. You'll find other helpful articles, detailed tutorials, and videos in this all-things-Serverless content collection. New articles are published every day — that's right, every day — from community members and cloud advocates in the month of September.

Find out more about how Microsoft Azure enables your Serverless functions at https://docs.microsoft.com/azure/azure-functions.

Introduction

No matter which tech event you attend, there will be someone talking about Microservices. It may not be for you at this moment but it's a fact that Microservices architecture advances loosely coupled services which can be developed, deployed and scaled independently. This architecture style also bring some challenges to the table and I'll address one of them in this article.

Saga Pattern

In order to ensure data consistency across multiple services, we often implement the Saga pattern: a sequence of local transactions. If a local transaction fails for some reason the Saga executes a series of compensating transactions that undo the changes that were made by the preceding local transactions.

This idea is not new, I've learned about it many years ago from my friend and professor Felipe Oliveira (@scaphe), but on that time it was applied to Services Oriented Architectures (SOA). There are two ways to implement the Saga Pattern:

Choreography: each local transaction publishes domain events that trigger the execution of transactions in other services;
Orchestration:the logic and order of execution lives on an orchestrator that commits / rollback all the phases related to that business logic;

Using Azure Functions in addition with Durable Functions, you can easily implement a serverless Saga Orchestrator (using FanOut and/or Function Chains):

Sample

In order to keep this example simple, I'll leave just the orchestrator logic in this article:

    public static class OrderSaga
    {
        [FunctionName("OrderSaga")]
        public static async Task<bool> RunOrchestrator(
            [OrchestrationTrigger] DurableOrchestrationContext context)
        {
            var orderId = context.GetInput<Guid>();

            Task<bool> orderResponse = context.CallActivityAsync<bool>("OrderActivity", orderId);
            Task<bool> paymentResponse = context.CallActivityAsync<bool>("PaymentActivity", orderId);

            await Task.WhenAll(orderResponse, paymentResponse);

            if (orderResponse.Result == false || paymentResponse.Result == false)
            {
                await context.CallActivityAsync("RollbackOrderActivity", orderId);
                await context.CallActivityAsync("RollbackPaymentActivity", orderId);

                return false;
            }

            return true;
        }

What is happening under the hood?

Durable functions expose an endpoint where we can monitor the progress and the output of each activity. It also persists the output from each activity and it has retry logic implemented by nature. All you have to do is implement the success / failure logics into your activities, then use the orchestrator to commit or rollback each phase, just what we've did previously.

More information

You can find more information in the following links:

Microservices: Microservices.io
Saga Pattern: Saga Pattern
Durable Functions on: Docs Azure
This Sample available on my Github: Thdotnet