DEV Community: Christopher Maneu

Get your SQL Server dev environment ready in one click

Christopher Maneu — Tue, 25 Oct 2022 15:35:16 +0000

Setting up a development environment is – most of the time – cumbersome. Technologies like Docker and Visual Studio Code Remote Containers – and GitHub Codespaces – really help a lot.
We’ve just released a new sample, Try Out Development Containers: SQL Server & Azure SQL that get you ready to work on your databases projects, just in one click!

One-click to SQL Server development

If you click on the button below, you will open an instance of Visual Studio Code – if it’s installed – spin up a new SQL server instance and automatically add relevant Visual Studio Code extensions.

When you have opened this template, you can directly write SQL files, execute them either through the SQLCMD CLI or use the SQL Server extension to visualize your database right from the Visual Studio Code interface. You have everything ready to work on your database projects.

Easily deploy database schema changes

This sample uses the SQL Database Projects extension. This extension allows you to organize your SQL files into a database project. This extension allows you to:

Create a database schema from a Swagger or Open API definition
Compare your database to your database numbers
Deploy your database project to an Azure SQL database or a SQL Server instance

Use it for learning or for your next project

You can use this Dev Container quick start simply to learn how to use Azure SQL or SQL Server. But you can also simply Use this Template within GitHub to create your next database project and get everything already setup for you.

Deploy Meilisearch on Azure in One Click

Christopher Maneu — Fri, 18 Feb 2022 15:53:41 +0000

If you're developing an application, chances are that you need some search capabilities. In this area, users have been accustomed to blazing-fast search experiences like the ones on modern search engines.

Truth is, providing a great search experience from just an autocomplete box is quite hard. Enter Meilisearch, an open-source search API. It's easy to use, blazing fast, and comes with SDKs for a wide range of languages.

So, let's see how easy it is to host it on Azure 🚀

One-click deploy

If you're in a hurry, just click that big blue button and do not forget to replace the Application Name with something more personal.

Click on the Create button, wait a few minutes while the deployment is happening...and that's it! Your Meilisearch instance is up and running. You can access your instance via a custom URL of the generated App Service. You can see it by clicking the Outputs tab on the left. The API is accessible on the 433 port and not the default 7700 port.

Host Meilisearch on Azure Web Apps for Containers

Let's see under the hood how you can easily host Meilisearch on Azure. As Meilisearch is created in Rust, the best way to host it is probably to use their container image. With Azure App Service, you can easily host and scale containers without having to deal with Kubernetes or OS updates.

Create an Azure App Service

If you're not familiar with Azure App Service, I encourage you to follow this tutorial. Onwards, I'll assume you have a basic knowledge of this service :).

If you try to deploy getmeili/meilisearch image, it'll not work the first time. This is due to the port exposed by the image - which is by default 7700. We need to inform Azure App Service to map this port behind the SSL termination done by App Service. For this, you must add the environment variable WEBSITES_PORT with the value 7700.

Meilisearch recommends setting a master API Key. You can do so by adding the MEILI_MASTER_KEY environment variable with some long & complex values.
Once this is done, you can try your instance right away! If you're also new to Meilisearch, checkout their quick start!.

Setup shared storage

But what happens if you stop or restart your instance? All your indexed data is gone!

Well, this is quite expected. Azure App Service is by default a stateless service: all data written on disk will be lost at some point (service restart, reimaging, ...). So you need to configure what we call Path mappings. This feature will map a folder within the container to a specific file share. Hence all data stored there will be persisted even if the container is restarted.

You can see how to mount a storage mapping to a Linux container in our documentation.

The last thing you must do is to add the environment variable MEILI_DB_PATH with the path used in your path mapping.

That's it, you now have a Meilisearch instance hosted on Azure :).

#julyot Devs, Learn the basics of IoT Solutions this month!

Christopher Maneu — Wed, 08 Jul 2020 11:22:41 +0000

Hey Fellow developers,

Are you interested in IoT but never had time - or hardware - to start? Don't know where to start? Let's start together this month!

I'm running a series of Live streaming about IoT solutions, every Thursday 5pm CET-Paris Time / 8am PST-Seattle Time at https://julyot.café.dev. You'll be able to follow along within your browser my course with the Microsoft Learn Platform (https://aka.ms/julyot/learn/).

Watch the first episode

The first episode of the series aired last week. With one of my colleague Benjamin, we've introduced what is an IoT Gateway and how to host it easily on Azure.

Next episode: Use SaaS solutions to build your own IoT Solution

I'll be streaming live tomorrow (July 9th) about how you can use SaaS IoT product - Azure IoT Central - to create your own IoT Solution with very limited amount of code - or even no code at all sometimes!

Join me Live on YouTube.

Deploy Blazor WebAssembly apps to Azure Static Web Apps

Christopher Maneu — Tue, 19 May 2020 17:35:40 +0000

Azure Static Web Apps is a new service that allows you to easily deploy your Static web apps. As I'm working on a little
Blazor Client App (with WebAssembly), It seems perfect to host it on Azure Static Web Apps. Here is a guide about how
I've done it, and how you can do it for your own projects too!

What is Blazor?
Blazor is a Web UI framework that allows you to create
dynamic client apps by using C# instead of JavaScript. It's using WebAssembly to execute C# code within the browser
sandbox.

The plan

Deploying your Blazor App on Static Web App should take you less than 10 minutes! Here is the plan:

Create your Blazor project and upload it to a GitHub repository (public or private),
Create your Azure Static Web App,
Customize the build,
Customize URL Routing to forward navigation to Blazor Routing.

Let's get started!

Create your Azure Static Web App

Let's say I've pushed my application into a GitHub repo already, and the project is within src/frontend folder.
The first step to take is to create your Static Web App within the Azure portal :).

Static Web App (or SWA) has a free tier, so even if you don't have an Azure Subscription, you can create a trial
subscription and use it for free ;)

After clicking to Create new resource type Static Web Apps in the search box. Click on Create button.

You'll now have to enter few basic info, like the Subscription or the Resource Group (a container for your resources).
The name of the static web apps is only for you. It'll not be a part of the website address. The website address will be
automatically generated, and you can later customize it with your own domain name.

The last step is to specify the GitHub source repository and branch. The first time you're using SWA, you'll need to
authorize Azure to access your repositories. By doing so, it'll automatically create a new GitHub Action to build and
publish your website.

For now, Azure will create a commit on the specified branch with a new GitHub Action. If you already have other actions
they should not be affected.

The second step is to instruct SWA about where your app is and how to build it. For now, SWA doesn't support building
Blazor Apps, but there is a trick :): Build it beforehand in GitHub Actions and point SWA to the build output folder.
In my case, it's
src/frontend/bin/Release/netstandard2.1/publish/wwwroot. I'll leave the Api Location and App Artifact location
empty.

Click on Review+Create, confirm the creation and let's jump onto the second step!

Update GitHub Actions

As I said before, we will have to build our Blazor project before deploying it to SWA. Go onto your Git/GitHub repo
(don't forget to git pull if you're working locally) and locate the GitHub Action .yaml file created by SWA.
It should start with azure-static-web-apps. Then add the following steps before the SWA - name: Build And Deploy
step. You may need to change the paths accordingly to your project structure.

    - name: Setup .NET Core
      uses: actions/setup-dotnet@v1
      with:
        dotnet-version: 3.1.201

    - name: Build with dotnet
      run: dotnet build --configuration Release

    - name: Publish with dotnet
      run: dotnet publish --configuration Release 

    - name: Publish artifacts
      uses: actions/upload-artifact@master
      with:
        name: webapp
        path: src/frontend/bin/Release/netstandard2.1/publish/wwwroot

As you've probably spotted, I'm also capturing the build artifacts here. This step is not mandatory; however, I like to
keep an archive of what's been deployed. You can remove this step if you want.

Commit-Push this change to this repository and head over to the Actions tab on GitHub. Within minutes, your Blazor
website should be deployed! Congrats 🎉

Fix URL Routing with Blazor

Almost all Blazor apps have several pages. So, what happens if a user is trying to reach for example
yourapp.com/second-page? It will fail. That's because this page - or directory - does not exists in your output and
that's normal. We need to tell SWA to serve our index.html for all non-matching routes, so Blazor routing can
kick-in and resolve the appropriate Blazor Page.

And it's easy! You just need to create a routes.json file with the following content.

{
  "routes": [
    {
      "route": "/*",
      "serve": "/index.html",
      "statusCode": 200
    }
  ]
}

The only remaining question is Where to create this page? It should be at the root of your published folder.
For most of the projects, you can put it onto your wwwroot folder. Do not forget to set Build action to "Copy Always" ;).

You now have successfully deployed your Blazor App to Static Web Apps!

What about some Azure Functions?

For now, Static Web Apps only supports Azure Functions written in Node JS. If your functions are also written in NodeJs,
you can simply specify the functions folder in the YAML file.

If your functions are written in C#, for now, you can create another action to publish them directly to Azure Functions.

How YOU can interview developers remotely with Visual Studio Code?

Christopher Maneu — Mon, 20 Apr 2020 14:15:16 +0000

Photo by Christina @ wocintechchat.com on Unsplash

This article was written during Covid-19 crisis. However, It's relevant before and after this time.

You're about do interview some developers remotely? Great! But how to asses the level
of a developer when she/he's not in front of you?

In this article, we'll see:

How a remote developer interview is different from an onsite one?
How you can simply organize coding exercises of different forms remotely?
How you can do live coding exercises during an interview?

In this article, I'll focus on interviewing remotely, and not for a remote position.
Interviewing for a remote developer position has some specifics. If you're interested in this topic,
feel free to drop me a message in comments section. Moreover, some countries have laws that forbid
a remote interview process or limit it.

Start with what?

As any software developer, I've done a bunch of interviews. From startup to two of the GAFAM, I had quite different
exercises, and some of them made absolutely no sense to my ability to integrate a team and be a good developer.

As an engineering lead, I've always tried to ensure that the interview process evaluate two things:

The ability of the candidate to integrate a team, communicate and collaborate.
The ability of the candidate to create software depending on our current setup and the seniority level.

In all my experience, I've never seen any actual developer writing code on the whiteboard and use it in production
thereafter. We must force ourselves to put the candidate in a position & context as close as a team member would be.
That's why I like to ask questions about communication and collaboration first, and then put the candidate "at work"
by letting her/him write code. Let's see how to do it easily with Visual Studio Code!

Launch audio-visio easily

First things first! Every interview will start with a quick call. There are a gazillion options out there:
Google Hangouts, Microsoft Teams, Z**m, etc... The fact is we tend to forget simple things: Skype! If it's not perceived
as a professional tool, Skype has a neat conference call feature that checks every criterion you should have for a
videoconferencing tool for remote interviews:

A straightforward way to setup the call
Should work with almost any platform (Windows, Mac, Linux, iOs, Android, ...)
Should not require any account or download. And yes, Skype Conference call allows anybody to make a phone call within the browser!
Allows several people in
No call limitation (you don't want to hang up after 40 minutes)

You can simply create a new meeting here.

The only caveat for now is that you will not be able to share your screen from the web interface. Anyway, we'll see in a
minute how to do better than sharing a screen.

Coding exercise at home

In my previous company, every developer candidate must complete a simple exercise to code on their own.
How we've done this?

We give the candidate a simple exercise (Create a master-details app based on a publicly available API) and all the details required in less than a sheet of paper (with less than 5 min reading, you should have everything to start)
We asked that all the exercise code was handed over on a public or private Git repository (most candidates choose the private repo option. We provided the private repo).
The code has no value for us. As we were not paying anything to the candidate, no code should be valuable for us.
The candidate can work on this exercise for two weeks on her/his own terms: 1h per day, 1 weekend day, full time. With Internet or without, with any IDE. Sometimes we restricted the libraries and packages that can be used but that's all.

However, it was not a perfect setup. Candidates had to setup a new project from scratch, and a development environment.
We had to take their code and execute it. Sometimes we had some tweaks to make it work on our own dev environment. It
was also complicated during the next interview to comment their code live.

But we're in 2020, and thanks to Visual Studio Code, Docker and Remote Development Extensions
, it's now super-easy to setup a development environment within a Docker container, and share it!
Read this tutorial to get started.

With this simple extension, you can now either setup a dev environment ready for your exercise, or ask your candidate
to provide you this container, so you can review the exercise easily and in an isolated fashion.

Unsupervised time-boxed coding exercise

In one of my first company, we had to complete a coding exercise in two hours. This company has to setup a real computer
, and erase it at the end of the exercise. It was a tedious process.

With remote development extension, this process is now easy. Giving it to a remote candidate is however not easy.
Thanks to Visual Studio Online, you can now host a complete development environment
in Azure and access it via a Visual Studio Code embedded in a browser interface. It's easy to setup,
and you can share an account with the candidate. When the time is up, you can simply access the environment to review
the exercise.

Pair programming & supervised coding exercise

One of my favourite exercise (and an ideal replacement of a whiteboard coding session) is a "pair programming"
session. It may be difficult to produce any code in 45 minutes, but you can plan a lot of exercises:

Going through a "fake" pull request and ask the candidate to comment the code,
Ask the candidate to code a simple piece of code and watch it doing so,
Ask the candidate to write some unit tests based on a feature description

Thanks to Visual Studio Live Share,
it's easy to setup these kinds of interviews. You can simply share a code and a development environment
with a remote candidate. It's even easier now that you can Join in the browser!

Whiteboard exercise

Ok, ok. I see you still want to do some whiteboard exercise. As I said before, you need to be very intentional
about these kinds of exercises. Even in person, they are hard to run and evaluating a candidate performance with them
is complicated. However, you may want to run a quick whiteboarding exercise before a pair programming one.
Thanks to Live Share Whiteboard
extension, you can run a shared whiteboard session directly within Visual Studio Code. Used in combination with
the other tools, it can be an effortless way to run an end-to-end design & coding exercise with only one tool.

How you're running your own remote interviews? Is there anything you want to know about this that's not answered in this post? Add a comment below!

Let's share our 2020 Dev Resolutions!

Christopher Maneu — Wed, 01 Jan 2020 08:30:16 +0000

🎊 Happy new year to everyone! 🎉

I hope you all get some time to recharge your batteries and enjoy quality time with your beloved ones - family, friends, ...

We're entering a new decade today, and I'm excited about what's coming next for all of us. 2019 has seen the rise of a lot of topics that - for me - that promise a bright future :

I witnessed a lot of people getting their first job in tech - from more diverse backgrounds than ever,
A lot of cloud-related technologies have enabled developers to create more efficient and powerful services: container orchestrators, serverless, ...
Even if some places in the world don't have proper/unregulated access to the Internet, it's easy to build IoT projects with a diverse range of connectivities. Despite the security risks, we've seen a lot of new IoT devices deployed everywhere
A new generation of developers is coming: the Citizenship Developers. With new low-code or no-code solutions, a lot of professionals - whatever their background- can create software to optimize their business or daily work.

So, what YOU will do in 2020? #2020DevResolutions

As every year, It's resolutions time! Eat healthier, do more exercise, become greener. We all try to commit to them at the beginning of the new year. What's hard is to make them a habit and keep these resolutions over time. One of the best ways to achieve this is to make ourselves accountable by sharing these resolutions with other peoples.

That's why I encourage you to share your developer resolutions on Twitter with the hashtag #2020DevResolutions. Just one tweet, that's all I'm asking :). You can do it now 👉
Tweet #2020DevResolutions

If you want to "write" something about it - a blog/dev.to/medium post, a video, etc...- Go do it!

Do you need some ideas?

There are so many things to do, right? To give you some inspirations, I'll publish or retweet one developer resolution per day on Twitter. That's 31 ideas to pick from :) Be sure to follow me Follow @cmaneu and follow

I'll also share a weekly blog post. Every Monday, I'll create a digest with the best developers resolutions I saw on Twitter, and to help you adopt these resolutions, I'll create a plan for some of them.

🌟 Let's have a stellar Developer year together! 🌠

How to get usable state from IoT events? #25daysofserverless

Christopher Maneu — Sat, 21 Dec 2019 07:50:39 +0000

This article is part of #25DaysOfServerless. New challenges will be published every day from Microsoft Cloud Advocates throughout the month of December. Find out more about how Microsoft Azure enables your Serverless functions.

Have an idea or a solution? Share your thoughts on Twitter!

Let's head over to South of France where Julie and her colleagues have decided to prepare a special gift for all patients
where she is working: custom-shaped inflated balloons! To make them, she'll need to inflate a LOT of balloons
with the help of an air compressor and one 12 liters air tank. Will they have enough air to do it?

We have put some IoT devices that tell us when the air compressor is starting and stopping to fill the tanks.
With the help of Azure IoT Hub and some serverless magic, your mission is to compute the amount of air available and
make this information available.

Create our Project

After having created a new Azure Functions project, we will need to install the Azure Functions Durable extension, by adding the corresponding NuGet package.

func extensions install -p Microsoft.Azure.WebJobs.Extensions.DurableTask -v 2.0.0

You'll also need to create several Azure Resources, including:

A Storage Account. Your entity state will be serialized into it,
An Event Hub, to reroute messages from the IoT Hub to the Azure Function
An IoT Hub and a device that sending some messages :) (you can fake it if needed.

Coding our Durable Entity

That's probably the easiest part. You simply have to write a class, with some assumptions and todos :

Any property will be only read-only. If you need to change the state of an object, you will need to create a method for it. Methods will be called, but not directly,
We will only serialize what's needed. So you need to put some attributes for this,
Any public method can be called by other functions
You'll need a special Run method that will dispatch the actual work to the appropriate method. Remember, methods are not called directly on your object.

Here is a simple example of a class representing a Tank, with different properties.

[JsonObject(MemberSerialization.OptIn)]
public class Tank
{
    [JsonProperty("pressure")]
    public int CurrentPressure {get; private set;} = 0;

    [JsonProperty("isFilling")]
    public bool IsFilling {get;private set;}

    [JsonProperty("fillingStartTime")]
    public DateTime FillingStartTime {get; private set;}

    [FunctionName(nameof(Tank))]
    public static Task Run([EntityTrigger] IDurableEntityContext ctx)
        => ctx.DispatchAsync<Tank>();

    public int GetActualPressure() => this.CurrentPressure;

    public void StartFilling()
    {
        IsFilling = true;
        FillingStartTime = DateTime.Now;
    }

    public void Stop()
    {
        IsFilling = false;
        var fillingStopTime = DateTime.Now;
        CurrentPressure += ComputeFillingPressure(FillingStartTime, fillingStopTime);
    }
}

Calling a method on our durable entity from regular functions

At the previous step, we've created some methods like StartFilling and Stop. We now need to call it when we receive an event from our IoT device.

If you try to instantiate an entity directly, you'll have the feeling that's everything is working. However, nothing will work :). You'll need to use an IDurableEntityClient to communicate with a durable entity. This client will handle all the work behind the scenes to scale, serialize and restore your entities. You get this client via method parameters injection.

In a case of just calling a method in an entity without expecting any return value, you'll be simply signaling it. That means that your Azure function will almost always return before any code within the entity gets executed. You just create an EntityId and call the method SignalEntityAsync() to send a request to execute a specific method.

[FunctionName("processCompressorEvent")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req,
    ILogger log,
    [DurableClient]IDurableEntityClient client)
{
    log.LogInformation("New event from IoT device.");

    string compressorId = req.Query["id"];
    string queryType = req.Query["eventType"];

    var entityId = new EntityId(nameof(Tank), compressorId);

    switch (queryType)
    {
        case "start": 
            await client.SignalEntityAsync(entityId, "StartFilling");
            break;
        case "stop": 
            await client.SignalEntityAsync(entityId, "Stop");
            break;
    }

    return (ActionResult)new OkObjectResult($"Event processed.");
}

Accessing values of our durable entity from regular functions

If you need to access the value of an entity, it's almost the same than calling a function:

Use an IDurableEntityClient,
Create an EntityId object to _locate _ your entity,
Call durableEntityClient.ReadEntityStateAsync()

There is only one thing you need to know: if you try to get an entity state for an entity that does not exists yet - because nobody called a method on it for example - You'll get a "value that is null". That's why the return value of ReadEntityStateAsync is not your object, but a wrapper object that exposes an EntityExists property.

[FunctionName("GetCompressorState")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
    ILogger log,
    [DurableClient]IDurableEntityClient client)
{
    log.LogInformation("New request to get compressor state.");

    string compressorId = req.Query["id"];

    var entityId = new EntityId(nameof(Tank), compressorId);
    var currentValue = await client.ReadEntityStateAsync<Tank>(entityId);

    if (currentValue.EntityExists)
        return (ActionResult)new OkObjectResult( new { value = currentValue.EntityState.CurrentPressure});
    else
        return (ActionResult)new OkObjectResult( new { value = 0, state = "no-data"});
}

Voilà ! With very few lines of code, you're now able to store a concrete state of an IoT object just from events data, and you're ready to scale it to millions of balloons :).

Want to submit your solution to this challenge? Build a solution locally and then submit an issue. If your solution doesn't involve code you can record a short video and submit it as a link in the issue description. Make sure to tell us which challenge the solution is for. We're excited to see what you build! Do you have comments or questions? Add them to the comments area below.

Watch for surprises all during December as we celebrate 25 Days of Serverless. Stay tuned here on dev.to as we feature challenges and solutions! Sign up for a free account on Azure to get ready for the challenges!

Enjoying this initiative by Azure Advocates? Stay in touch via our newsletter.

#Tip Use local Azure Storage emulator in Remote Containers

Christopher Maneu — Mon, 09 Dec 2019 12:10:03 +0000

I LOVE Remote Development Extensions for Visual Studio Code. It allows me to simply pack all my technical stack in one docker container, while getting me everything I need to run and debug things.

Everything, this includes `localhost`, right?

Ehmm.. that depends! This morning, I was doing different things with Azure Functions SDK for 25 days of serverless, and for that I needed to access the local Azure Storage Emulator, the one on my local machine - not within a Docker container.

How can I possibly access local resources - who are neither on Internet or within another container - from a container?

3 magic words

host.docker.internal. That's all you need within your container to access your "real" localhost, and everything hosted on it. Like my Azure Storage Emulator :). With that bit of magic, I was able to replace the usuel local connection string UseDevelopmentStorage=true; by the following :

UseDevelopmentStorage=true;DevelopmentStorageProxyUri=http://host.docker.internal

Et voilà! I'm now able to use the benefits of Remote Containers development while using all my local hosted tools, including the Azure Storage Emulator :)