<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Maxime Rouiller on Medium]]></title>
        <description><![CDATA[Stories by Maxime Rouiller on Medium]]></description>
        <link>https://medium.com/@MaximRouiller?source=rss-2022f1387a6a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*AwpU6W_A0MqJez0qCLq2ow.jpeg</url>
            <title>Stories by Maxime Rouiller on Medium</title>
            <link>https://medium.com/@MaximRouiller?source=rss-2022f1387a6a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 06:28:14 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@MaximRouiller/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Fixing Azure Functions and Azure Storage Emulator 5.8 issue]]></title>
            <link>https://medium.com/@MaximRouiller/fixing-azure-functions-and-azure-storage-emulator-5-8-issue-5cc7b3cb2ec7?source=rss-2022f1387a6a------2</link>
            <guid isPermaLink="false">https://medium.com/p/5cc7b3cb2ec7</guid>
            <category><![CDATA[azure-functions]]></category>
            <category><![CDATA[serverless]]></category>
            <category><![CDATA[azure]]></category>
            <dc:creator><![CDATA[Maxime Rouiller]]></dc:creator>
            <pubDate>Tue, 19 Mar 2019 14:43:41 GMT</pubDate>
            <atom:updated>2019-03-19T14:43:41.506Z</atom:updated>
            <content:encoded><![CDATA[<p>So you’ve updated Azure Functions to the latest version (2.X at the time of writing this), and nothing starts anymore.</p><p>Now, when you boot the Functions host, you get this weird error.</p><pre>[TIMESTAMP] A host error has occurred <br>[TIMESTAMP] Microsoft.WindowsAzure.Storage: Server encountered an internal error. Please try again after some time.</pre><p>There happen to be <a href="https://github.com/Azure/azure-functions-host/issues/3795">an issue opened on GitHub</a> that relates to Durable Functions and Azure Storage Emulator.</p><p>The thing is, it’s not directly related to Azure Durable Functions. It’s related, in my opinion, in a breaking change that happened in Azure Storage Emulator 5.8 ways of responding from its API.</p><p>If you want to fix that issue, merge the following setting in your local.settings.json file.</p><pre>{<br> “Values”: {<br> “AzureWebJobsSecretStorageType”: “files”<br> }<br>}</pre><p>This only applies when &quot;AzureWebJobsStorage&quot;: &quot;UseDevelopmentStorage=true&quot;.</p><p>So why should we set that? There was a change that was introduced back in September 2018 when Azure Functions V2 was released. Azure Functions store your secret on disk before 2.0. Azure Functions, when <a href="https://docs.microsoft.com/azure/app-service/deploy-staging-slots?WT.mc_id=maximerouiller-blog-marouill#swap-two-slots">slot swapping environments</a>, swap the content of the disk including the secrets.</p><p>What this setting does is ensure that Functions stores secrets on your file system by default. It’s expected behavior when using a local development environment.</p><p>If you want to read more, there is <a href="https://github.com/Azure/azure-functions-host/wiki/Changes-to-Key-Management-in-Functions-V2">an entire article on that behavior</a>.</p><h3>Conclusion</h3><p>To fix the issue, you can either use the workaround or <a href="https://docs.microsoft.com/azure/storage/common/storage-use-emulator?WT.mc_id=maximerouiller-blog-marouill">update the Azure Storage Emulator to 5.9</a>.</p><p><em>Originally published at </em><a href="https://blog.maximerouiller.com/post/fixing-azure-functions-and-azure-storage-emulator-58-issue/"><em>blog.maximerouiller.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5cc7b3cb2ec7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to build a multistage Dockerfile for SPA and static sites]]></title>
            <link>https://medium.com/@MaximRouiller/how-to-build-a-multistage-dockerfile-for-spa-and-static-sites-d0b24ffd2da?source=rss-2022f1387a6a------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0b24ffd2da</guid>
            <category><![CDATA[nginx]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[single-page-applications]]></category>
            <category><![CDATA[nodejs]]></category>
            <dc:creator><![CDATA[Maxime Rouiller]]></dc:creator>
            <pubDate>Thu, 21 Feb 2019 19:22:08 GMT</pubDate>
            <atom:updated>2019-02-21T19:22:08.411Z</atom:updated>
            <content:encoded><![CDATA[<p>When you are a consultant, your goal is to think about the best way to save money for your client. They are not paying us because we can code. They are paying because we can remove a few dollars (or a few hundred) from their bills.</p><p>One of the situations we often find ourselves in is building a single page application (SPA). Clients want dynamically driven applications that don’t refresh the whole page, and a SPA is often the perfect choice for them. Among the many tools used to build a SPA, we find Angular, Vue, and React.</p><p>I’ve found that delivering websites with containers is a universal way of ensuring compatibility across environments, cloud or not. It also prevents a developer’s environment from having to install 25 different tools/languages/SDKs.</p><p>It keeps thing concise and efficient.</p><p>If you want to <a href="https://docs.microsoft.com/dotnet/standard/containerized-lifecycle-architecture/what-is-docker?WT.mc_id=medium-blog-marouill">know more about Docker containers</a>, take a few minutes, in particular, to read about <a href="https://docs.microsoft.com/dotnet/standard/containerized-lifecycle-architecture/docker-terminology?WT.mc_id=medium-blog-marouill">the terminology</a>.</p><p>The problem is that we only need Node.js to build that application, not to run it. So, how would containers solve our problem? There’s a concept in Docker called <a href="https://docs.docker.com/develop/develop-images/multistage-build/">Multistage builds</a> where you can separate the build process from the execution.</p><p>Here’s a template you can use to build a SPA with Node.js.</p><h3>Dockerfile template for Node.js</h3><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/af77581d4ee6f341da0211152e1f3ef3/href">https://medium.com/media/af77581d4ee6f341da0211152e1f3ef3/href</a></iframe><p>There’s a lot to unpack here. Let’s look at the two stages separately.</p><h3>Build Stage (Node.js)</h3><p>Multistage docker builds allow us to split our container in two ways. Let’s look at the build stage.</p><p>The first line is a classic. We’re starting from an Alpine image that has Node.js pre-installed on it.</p><blockquote><em>Note: Alpine Linux is a security-oriented, lightweight Linux distribution based on musl libc and busybox. Its main characteristic is it runs everywhere and is extremely small, around 5MB.</em></blockquote><p>We’re configuring /app as the working directory. Then, we do something unusual. We copy our package*.json files before copying everything else.</p><p>Why? Each line in a Dockerfile represents a layer. When building a layer, if a layer already exists locally, is retrieved from the cache instead of being rebuilt. By copying and installing our packages in a separate step, we avoid running npm install on dependencies that didn’t change in the first place. Since npm install can take a while to install, we save some time there.</p><p>Finally, we copy the rest of our app and run the npm build task. If your application doesn’t have a build task, change the name to whatever tasks generate an output folder like dist.</p><p>The result? We have a correctly built Node.js application located in /app/dist.</p><h3>Production Stage</h3><p>We’ve generated our SPA or static site with Node.js but… our application isn’t using Node.js. It’s using HTML/CSS/JS. We don’t need a Node.js image to take our application to production. Instead, we only need an HTTP server. Let’s use the <a href="https://hub.docker.com/_/nginx">NGINX Docker Image</a> as a host.</p><p>We copy the output from our previously defined build-stage /app/dist folder into the NGINX defined folder /usr/share/nginx/html as <a href="https://github.com/docker-library/docs/tree/master/nginx#how-to-use-this-image">mentioned in their docs</a>.</p><p>After exposing port 80, we need to run NGINX with the daemon off; option to have it run in the foreground and preventing the container from closing.</p><h3>Building the Dockerfile</h3><p>This step is easy. Run the following command in the folder containing the Dockerfile.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/151e52ab975a8119d750de8cd415f775/href">https://medium.com/media/151e52ab975a8119d750de8cd415f775/href</a></iframe><h3>Running the Docker container locally</h3><p>Running the application on your machine is of course just a simple command away.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/adb572235f34dd5e2fb1245fff020eac/href">https://medium.com/media/adb572235f34dd5e2fb1245fff020eac/href</a></iframe><p>This command is doing two things. First, it runs the container in interactive mode with the -i flag. That flag will allow us to see the output of NGINX as it runs. Second, it maps port 8080 of your local machine to port 80 of the container.</p><p>Opening your browser to http://localhost:8080 will show you your website.</p><h3>Conclusion</h3><p>I’m using Docker more and more for everything. I’m building applications that are single use with current technology. Docker empowers me in running applications with older versions of frameworks, runtime, languages, without causing tooling versioning issue with my machine.</p><p>While technology may continue to evolve, I’m never afraid that my Docker container won’t work anymore. Things have been stuck in time if only for a moment.</p><p>That means I don’t have to upgrade that AngularJS 1.X app to stay cool. If it works, it works.</p><p>Are you using Docker in unusual ways? Share them with me <a href="https://twitter.com/MaximRouiller">on Twitter</a>!</p><p><em>Originally published at </em><a href="https://blog.maximerouiller.com/post/how-to-build-a-multistage-dockerfile-for-spa-and-static-sites/"><em>blog.maximerouiller.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0b24ffd2da" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Learn how to orchestrate serverless functions by scraping APIs in 8 minutes]]></title>
            <link>https://medium.com/microsoft/learn-how-to-orchestrate-serverless-functions-by-scraping-apis-in-8-minutes-ffec55b2501b?source=rss-2022f1387a6a------2</link>
            <guid isPermaLink="false">https://medium.com/p/ffec55b2501b</guid>
            <category><![CDATA[azure]]></category>
            <category><![CDATA[serverless]]></category>
            <category><![CDATA[azure-functions]]></category>
            <dc:creator><![CDATA[Maxime Rouiller]]></dc:creator>
            <pubDate>Mon, 06 Aug 2018 00:00:00 GMT</pubDate>
            <atom:updated>2018-08-13T18:36:01.591Z</atom:updated>
            <content:encoded><![CDATA[<p>The project I’m working on requires me to retrieve information from multiple sources like the NuGet and GitHub API. Let’s bring into focus how I’m downloading data from the GitHub API. If you follow me <a href="https://twitter.com/MaximRouiller/status/1019597611341402112">on Twitter</a>, you’ve probably already heard me talk about it.</p><p>Ever ended up on a sample that should be covering the problem you’re having, but it just doesn’t work? Then, you check the last commit date only to realize that it’s been 2 years since the last commit. The way the cloud is evolving, that sample is almost no good to you.</p><p>Well, some of the repositories on the Azure-Samples organization have those exact issues, and it’s one of the many problems that I’m trying to solve.</p><p>There are tons of samples on the <a href="https://github.com/Azure-Samples/">Azure-Samples</a> organization on GitHub, and I want to be able to check them out to see which ones are “too old.” What does a user consider a valid sample? For me, a valid sample is an up to date sample.</p><p>We need a way to retrieve those over 900 samples and validate their last commit date.</p><p>However, we first need to be able to retrieve all that information.</p><h3>File -&gt; New Project -&gt; Console Application</h3><p>Our first instinct as programmers is to try to do it once through a console application. It’s the minimum amount of complexity. If you can’t make it work in a console, there’s no hope of making it work anywhere else.</p><p>So, I went ahead and started by consulting the <a href="https://developer.github.com/v3/">GitHub API documentation</a>, created a GitHub token and started hunting for the information I need.</p><p>I ended up using the <a href="https://www.nuget.org/packages/Octokit/">Octokit</a> library to do all of my API access. The code to retrieve the last commit date is below.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/97bb6fcd93a2b14d7ebccf14750360c4/href">https://medium.com/media/97bb6fcd93a2b14d7ebccf14750360c4/href</a></iframe><h3><strong>First problem: Running locall</strong>y</h3><p>Everything was running fine, but the problem for me at that point was it was just a single console application running locally. I could have just taken the application as-is to containers, but I saw another way to solve this. I saw another way to scale it up. Azure Functions would help me scale it up.</p><p>By migrating the existing code into an Azure Function, the problem now was that it was still just a console application running inside an Azure Functions. This will just not cut it. We’re just running the same workflow in sequence. We need to execute this workflow in parallel and be able to scale out.</p><p>Once you know all the repositories that you want to query, it becomes a distributed problem. How many repositories can I hit at once without having any state to correlate between them? The answer is all of them.</p><p>I needed to refactor to make this process more sturdy. I needed it to be durable.</p><h3>Introducing Durable Functions</h3><p>If you are new to serverless, there’s <a href="https://docs.microsoft.com/dotnet/standard/serverless-architecture/serverless-architecture?WT.mc_id=appserviceteam-blog-marouill">an excellent book</a> by Jeremy Likness that can bring you up to speed. Azure Functions is Microsoft’s implementation of the serverless architecture. If you need a refresher, you can review the <a href="https://docs.microsoft.com/azure/azure-functions/functions-overview?WT.mc_id=appserviceteam-blog-marouill">Azure Functions Overview</a> on what is possible.</p><p>What is a <em>Durable</em> Function? With durable, it’s all about orchestration. Just like in music, the orchestrator ensures that everyone is following the melody, but it’s the responsibility of each musician to play their instrument.</p><p>Regarding Durable Functions, an orchestrator is in charge of starting and tracking a series of functions, but it’s the responsibility of each activities to execute their part. Think of the orchestrator as a workflow written in code and activities as the steps of the workflow. An orchestrator and an activity are still Azure Functions.</p><p>Let’s introduce two patterns that I’m using in my code.</p><h3>Function Chaining</h3><p>A pattern I want to cover quickly is <a href="https://docs.microsoft.com/azure/azure-functions/durable-functions-sequence?WT.mc_id=appserviceteam-blog-marouill">function chaining</a>. It’s the most straightforward and most commonly used pattern.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/825/0*5Q3Pf6Nw8oldQjvj.png" /><figcaption>Function Chaining</figcaption></figure><p>Everytime that your orchestrator awaits a function before running another one, you’re doing function chaining. Here’s the above image visualized in a code example.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/69b12f325862b16c0561d0768ee9b70b/href">https://medium.com/media/69b12f325862b16c0561d0768ee9b70b/href</a></iframe><h3>Fan-Out/Fan-In</h3><p>One of the Durable Functions design patterns I used is Fan-Out/Fan-In.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/577/0*r-qetpa901MXwxlt.png" /><figcaption>Fan-Out/Fan-In Pattern</figcaption></figure><p>Fanning out means that your orchestrator function (F1) starts as many functions (F2) as necessary in parallel with some initial parameters like the repository I want. Once all those functions have finished executing, we need a way to return the requested data to our orchestrator (F3). Keep in mind that, all those functions may not be executing on the same server. It is not as simple as a multi-threaded application. It’s a multi-threaded, multi-server, highly parallel execution workflow.</p><p>How would you do that in a local data center? A console application would retrieve the list of items on which you want to fan-out. Then, it would queue that list into a messaging system. Once queued up, you would have to have dequeue those messages asynchronously by other console applications that are on different servers. Each console applications would then be responsible for storing the result of their execution on shared storage. Once completed, you’d have to find a way to get the first console application to finish the workflow. Finishing the workflow would involve fanning in all the results back, and saving it to a database.</p><p>With Azure Functions, it’s as easy as returning an object. All the necessary work of storing the results of individual functions and aggregating them together is done automatically for you.</p><p>This scenario is a hard problem. Durable Functions just saved me easily one week of work and more days of testing, debugging, and refining the process.</p><p>Now that the introduction is complete let’s jump back to our scenario.</p><h3>Orchestrators are special functions</h3><p>Functions with the <a href="https://docs.microsoft.com/azure/azure-functions/durable-functions-bindings?WT.mc_id=appserviceteam-blog-marouill#trigger-behavior">OrchestrationTrigger behaves widely differently than normal Azure Function</a>. This trigger is what makes a normal Azure Function an Orchestrator Function. Just</p><p>Its behaviors are incredibly different than other Functions. It is called multiple times at different moment to orchestrate the execution of those functions. It is of the utmost importance that you do not calculate time and access external resources (e.g., SQL, Storage, API) in that context. The orchestrator is tasked to execute and track the status of those functions we started by executing itself repeatedly when something changes. You want the orchestrator function to be deterministic, meaning the same code executed at a different time need to give the same result. So no DateTime, no Math.Random or Guid.NewGuid() should be in an orchestrator.</p><p>It’s also important to note that every call that you make using CallActivityAsync won’t be executed more than once for the same orchestrator instance. Results are cached and handled by the Durable Functions.</p><p>CallActivityAsync is part of the concept that we call <a href="https://docs.microsoft.com/azure/azure-functions/durable-functions-checkpointing-and-replay?WT.mc_id=appserviceteam-blog-marouill">checkpoint and replay</a>. In simpler terms, this allows resuming the execution of the orchestrator while remembering the state of the execution of previous activities we ran in a reliable way across servers.</p><h3>Web Scraping scenario</h3><p>Here’s the code for my sample orchestrator.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/18633105440e37004b3dbfec317ccd3e/href">https://medium.com/media/18633105440e37004b3dbfec317ccd3e/href</a></iframe><p>So let’s decompose this together. First, I call a function to retrieve the list of over 900 Public Repositories available on Azure-Samples and await for the results before going any further. Then, we create an array of Tasks and go through our samples and start a function without an await for each of them. We’re <em>fanning out</em> the execution of those functions to be run and scaled by the cloud automatically. We’re not using await here. Otherwise, they would run sequentially instead of in parallel.</p><p>Then task then need to be awaited till completion. Finally, we aggregate the Samples object that has been returned by those functions into a list. Finally, we send it to a function to save them in a database. We’ve successfully <em>fanned-in</em> the results of 100s of functions. There is no need for a third-party system. No other configurations. No complex messaging architecture. Just code.</p><p>Just like that, we’ve made a complex parallel problem easy.</p><h3>Advanced Scenario: Orchestrating Orchestrators with Sub Orchestrators</h3><p>Isn’t it amazing? Now, I have an Orchestrator that instantiates over 900 DownloadSamples_UpdateRepositoryData functions to download data from the GitHub API. What would happen if I have multiple orchestrators of data ingestion that I want to make?</p><p>How do I orchestrate the orchestrators? We need another orchestrator of course! Here’s a simplified version of my code.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/dcd8d14682733bf8130f83619fc6bc97/href">https://medium.com/media/dcd8d14682733bf8130f83619fc6bc97/href</a></iframe><p>What does it do? Create a single <em>run</em> that is going to be used to invoke every other data ingestion orchestrator.</p><p>All those orchestrators are all going to start at 7 am every day at the same time. They are all going to run as described before. Only this time, they also report back to another orchestrator.</p><p>Once you start implementing simple workflows, it becomes effortless to build complex scenarios out of simple ones. The same patterns we approached that were used to build a single orchestrator can be used to orchestrate multiple sub-orchestrators.</p><h3>Why do I want this?</h3><p>Imagine working on a team with many different processes that need to run in parallel. Maybe one team is working on the shipping process, the other on the payment process. With a single orchestrator to manage multiple sub orchestrators, it makes team collaboration easier.</p><p>In my case, what if someone else wants to add the parsing of another API? They can work on their orchestrator and plug it in my MainDownloadOrchestrator function, and that’s it.</p><p>Scraping data from an API is just a single scenario. Whether you are building an order processing system, a conference organization tool or the next revolution in IoT data processing, we know that you need a way to organize complexity within your solution. We know that you want to reuse more significant part of your system than a single function.</p><p>Durable Functions is how you build complex systems with serverless.</p><h3>What is missing</h3><p>What you haven’t seen implemented is how to handle rate limiting. GitHub API has a limit of 5000 (at the time of writing) API calls per hour which is more than enough for the use that I make of it.</p><p>However, if other teams were to query GitHub some more, I’d need to look into implementing it. I still don’t have an elegant solution for this, but it’s going to be something I’m looking to implement next.</p><h3>Try it out</h3><p>If you want to try it out, Azure Functions comes with a free quota even with a trial account. If you need an account, <a href="https://azure.microsoft.com/free/?WT.mc_id=appserviceteam-blog-marouill">you can create one for free</a>.</p><h3>Contribute</h3><p>Azure Functions is also open source. Look at these repositories if you want to contribute or just want to know what’s going on with the project.</p><ul><li><a href="https://github.com/Azure/azure-functions-host">Azure Function Runtime</a></li><li><a href="https://github.com/Azure/azure-functions-core-tools">Azure Function CLI for local development</a></li><li><a href="https://github.com/Azure/azure-functions-ux">Azure Function Portal</a></li><li><a href="https://github.com/Azure/azure-functions-templates">Azure Functions templates for the portal and Visual Studio</a></li></ul><h3>Resources to get you started</h3><ul><li><a href="https://docs.microsoft.com/azure/azure-functions/functions-overview?WT.mc_id=appserviceteam-blog-marouill">Introduction to Azure Functions</a></li><li><a href="https://docs.microsoft.com/azure/azure-functions/functions-create-first-azure-function?WT.mc_id=appserviceteam-blog-marouill">Creating your first function in the Azure Portal</a></li><li><a href="https://docs.microsoft.com/azure/azure-functions/functions-create-scheduled-function?WT.mc_id=appserviceteam-blog-marouill">Running Azure Functions on a Timer Trigger</a></li><li><a href="https://docs.microsoft.com/en-us/azure/azure-functions/durable-functions-install?WT.mc_id=appserviceteam-blog-marouill">Installing the Durable Functions extensions</a></li><li><a href="https://docs.microsoft.com/en-us/dotnet/standard/serverless-architecture/durable-azure-functions?WT.mc_id=appserviceteam-blog-marouill">What is Durable Azure Functions?</a></li></ul><p><em>Originally published at </em><a href="https://blogs.msdn.microsoft.com/appserviceteam/2018/08/06/learn-how-to-orchestrate-serverless-functions-by-scraping-apis-in-8-minutes/"><em>blogs.msdn.microsoft.com</em></a><em> on August 6, 2018.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ffec55b2501b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/microsoft/learn-how-to-orchestrate-serverless-functions-by-scraping-apis-in-8-minutes-ffec55b2501b">Learn how to orchestrate serverless functions by scraping APIs in 8 minutes</a> was originally published in <a href="https://medium.com/microsoft">Microsoft</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>