Serverless Deno with Azure Functions
So far, I'm really enjoying my experience with Deno- I'd probably describe it as a lot like Node.js but with a design philosophy more akin with Golang. For example: Deno ships with a formatter, linter and test runner out of the box, and has a standard library built in. This, combined with it's out-of-the-box TypeScript support, has me very excited.
Unfortunately, a lot of cloud platforms don't explicitly support Deno yet- so unless you are running in containers you'll struggle for first-class runtime support. Luckily, Azure Functions have an option for custom language bindings, which allows developers to write functions using whatever language or runtime they desire, including Deno!
- Azure Functions Core Tools
- VS Code (strongly preferred)
- Deno Plugin for VS Code
- Azure Functions Plugin for VS Code
Creating an Azure Function project
Firstly, we need to create a new directory to house our code in. I'll use the
deno-functions but feel free to call it whatever you like. From your
Now that we are in the
deno-functions directory, we need to use our Azure
Functions Core Tools to initialise our function project so that the Core Tools
knows that we're dealing with Azure Functions. We do that using
func init and
specifying our desired runtime as
func init --worker-runtime custom
This will create a few files, but the most important one for our project is
host.json. This file tells our Azure Functions runtime how to run our
Configuring our project to work with Deno
In order for VS Code to allow us to write code using the Deno standard library,
we need to configure the project to enable the Deno plugin. If you already have
the Deno plugin for VS Code installed, you can press F1 on your keyboard and
select the option
> Deno: Initialize Workspace Configuration. After doing
this, you will be asked a couple of questions, and I would recommend the
- Enable Deno Linting: Yes
- Enable Deno unstable APIs: No
Alternatively, you can just create a
settings.json file in the
directory and include the following:
Creating our first function
Now we're all set up to work with Azure Functions and Deno, we're ready to
create our first function! We do this using the
func new command:
func new --name deno-http --template "HTTP Trigger" --authlevel anonymous
I have gone with the name of
deno-http but feel free to call it whatever you
want- just remember to swap in this name when I reference it later in the post.
This creates a new directory called
deno-http and inside it a
This file is used to declare the bindings for the function, along with the
authentication method, direction and method. We don't need to touch this file
any further, but if you'd like to, you can remove the
post entry from
methods as we won't need it for our use-case.
Now it's time to write our actual function code. Create a file in the
deno-http directory called
deno-http.ts. Again, the name doesn't matter
here, just keep it in mind when it's referenced in future. Populate your file
with the following code:
We have some important things to cover here.
Firstly, line 1 is now we import dependencies in Deno. If you've ever written any Go, this should look familiar. By referencing the url directly, we are able to know exactly where that code we are referencing is coming from.
Secondly, our code needs to be listening on the correct port. This is done on
line 3 by setting the port to the
variable provided by the Azure Functions runtime.
The rest of it should be fairly self-explanatory if you've ever seen a http
server written with TypeScript, but the general gist is that our function
returns a JSON object with the message of
Hello from Azure Functions with Deno!
Compiling our code into an executable
In order to run our code as a Function, we need to provide our Deno function as
an executable. We do this using the
deno compile command and provide it with
the path of the file we want to compile.
deno compile --allow-env --allow-net .\deno-http\deno-http.ts
Remember when I said earlier that Deno aims to be more secure than it's
predecessor? Well when we are running or compiling our Deno code, we must
specify if we want to allow our code to access environment variables or be open
to the network. We do that using the
We should now have an executable called
deno-http in the root of our
repository. We can run this executable just like any other web service and it
will give us exactly what we need - try it for yourself!
Running our executable as an Azure Function
Now that we've got an executable for our application, we need to point our
Function application to run it. We do that by modifying the
Open the file and replace the contents with the following:
The most important part of this lies within the
customHandler property. It
specifies the path to the executable and allows our Function host to forward our
HTTP requests to the correct port (this is incredibly important).
Once you have done that, open up your terminal and enter the following command:
Doing so will start up our Function host and inform us where our functions are accessible. When I do this on my machine, I get the following
Azure Functions Core Tools Core Tools Version: 4.0.4426 Commit hash: N/A (64-bit) Function Runtime Version: 126.96.36.19973 [2023-03-04T18:56:46.880Z] Listening on http://localhost:59769/ Functions: deno-http: [GET,POST] http://localhost:7071/api/deno-http For detailed output, run func with --verbose flag. [2023-03-04T18:56:47.331Z] Worker process started and initialized.
I can now access my function using the web browser or curl, and if this works, you should receive the following:
Deploying to Azure
Providing you have your Azure account set up properly, you can then deploy your function using the following command:
func azure functionapp publish deno-http
Alternatively, you can use the Azure Functions extension in VS Code to deploy your code if you prefer.
I appreciate that there are a lot of different ways of deploying Azure Functions, so I'm avoiding the topic of CI in the aim of not expanding the scope of this post too far.
I have written a lot of serverless functions in my career, but being able to use custom languages and runtimes may just change how we write them going forward.
I understand that Go and Rust are frequently used with Azure Functions in this context, but the possibilities for language are endless.
For example, you are able to write functions with scientific languages like R, which probably has a lot of use-cases in the data science world.
Deno is doing a lot of things right, and it makes me happy that I can pick it up so quickly and build something like an Azure Function with minimal overhead.
Also worth a mention is that Deno has it's own serverless platform to run on called Deno Deploy that apparently requires even less set up than Azure Functions. I can't speak from personal experience as I haven't used it myself, but based on my experience so far with Deno I may do soon!
You can find the source code for this blog post here.
Thanks for reading!