DEV Community: Jaquiel Paim

Docker built-in container support for .NET 7

Jaquiel Paim — Sun, 09 Oct 2022 22:15:40 +0000

On 14th September 2022, Microsoft announced .NET 7 Release Candidate 1, the first of two release candidates (RC) for .NET 7 that are supported in production.

The .NET 7 launch is scheduled for November 8-10, 2022 on the .NET Conf 2022! Until then we can try some of the new features and improvements of this new .NET release!

Among several new and interesting features, one that I particularly liked and would like to highlight here is just the docker built-in container support for .NET 7.

This new .NET 7 resource, which is part of one of the new cloud native features, helps .NET to further consolidate itself as an excellent alternative for building cloud-native applications and achieving resiliency, scalability, efficiency and speed in your web apps.

Let's get started

For this release, you must have Docker and .NET 7.0.100-rc.1.22431.12 or higher installed. Additionally, only Linux-x64 containers are supported.

Below we can see how simple it is to build a containerized ASP.NET application from scratch.

# 1st step - create a new project 
dotnet new mvc -n my-containerized-app

# 2nd step - move project to its directory
cd my-containerized-app

# 3rd step - add a reference to a (temporary) package that creates the container
dotnet add package Microsoft.NET.Build.Containers

# 4th step - publish your project for linux-x64
dotnet publish --os linux --arch x64 -p:PublishProfile=DefaultContainer

# 5th step - run your app using the new container
docker run -it --rm -p 5010:80 --name my-cloud-native-app my-containerized-app:1.0.0

If you are familiar with docker and the .NET CLI, or have already mastered them, you will probably have no difficulty understanding the above sequence of instructions.

However, if you're a beginner, let's take a look at each statement, step by step.

In the first and second steps, we just created a new .NET application with the ASP.NET Core Empty template and then moved to the new project directory.

$ dotnet new mvc -n my-containerized-app
$ cd my-containerized-app

dotnet new : command to create a new project
mvc : argument to set the .NET template project
-n : option for the created output

In the third step, we added Microsoft.NET.Build.Containers, a nuget package for publishing .NET applications natively as containers.

$ dotnet add package Microsoft.NET.Build.Containers

In our example we are using the empty mvc template, but in your own project what you need to do is just add this package to it.

Taking a look at a my-containerized-app.csproj file you can see the package there:

  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Build.Containers" Version="0.1.8" />
  </ItemGroup>

In the fourth step we compiled the application.

$ dotnet publish --os linux --arch x64 - p:PublishProfile=DefaultContainer

dotnet publish: command to compile the app
--os linux and --arch: options to specify the target operating system (OS) and specify the target architecture. We specified linux and x64, respectively. And it’s important to remember that only Linux-x64 containers are supported
-p: used for setting properties

If you type docker images in your console you could see that the image is already created:

REPOSITORY             TAG       IMAGE ID       CREATED         SIZE
my-containerized-app   1.0.0     b65f7ee7668a   7 seconds ago   220MB

Now, in the fifth and last step we finally run our container.

$ docker run -it -p 5010:80 --name my-cloud-native-app  my-containerized-app:1.0.0

docker run : container process that runs is isolated in that it has its own file system, its own networking, and its own isolated process tree separate from the host
-it : to run the container in interactive mode instead of detached mode, allowing us to execute commands while the container is in a running state
-p 5010:80 : definition of used ports. <port that we will use on our local host>:<port used inside the container>
--name my-cloud-native-app : to set a name for the container, preventing docker from generating a random name for it
my-containerized-app:1.0.0 : setting the image that we want to use, in this example, <name of our project>:<version defined by .NET>

If all goes well we will have a result similar to this below.

warn: Microsoft.AspNetCore.DataProtection.Repositories.FileSystemXmlRepository[60]
      Storing keys in a directory '/root/.aspnet/DataProtection-Keys' that may not be persisted outside of the container. Protected data will be unavailable when container is destroyed.
warn: Microsoft.AspNetCore.DataProtection.KeyManagement.XmlKeyManager[35]
      No XML encryptor configured. Key {2b3bd45e-0cc8-4cad-a0b9-ce5593370e33} may be persisted to storage in unencrypted form.
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://[::]:80
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Production
info: Microsoft.Hosting.Lifetime[0]
      Content root path: /app

Then, just access the application in any browser:http://localhost:5010/:

Conclusion

So, that 's it. We could see how simple this resource is and how useful it is for our projects. Unlike virtual machines, containers can rapidly scale in and out and are essential to cloud-native applications, offering granular scalability, portability and efficient use of resources.

Deno is out. Is Node dead?

Jaquiel Paim — Sun, 14 Jun 2020 18:00:31 +0000

In 13th May 2020, finally Deno is out, after two years of its first release.

For all the years of my career always I heard about the end of one or the other programing language or technology. So it was with Delphi, also PHP, within others. More recently it was the turn of the Node.Js.

One day, maybe every programming language will die (I'm not sure ...), but I really don't believe in the death of Node.js. At least not now.

But, what is Deno?

As written in the Deno documentation, it is a secure runtime for JavaScript and TypeScript that uses V8 and is built in Rust. You can see more details in https://deno.land.

Basically, Deno is a program for running JavaScript and TypeScript code outside of a browser, just like the Node.

Deno was created by Ryan Dahl, the same creator of Node, but now with focus in security and productivity. It was announced by Dahl in 2018 during his talk "10 Things I Regret About Node.js" at JSConf EU that year.

Introduction to Deno Features

First, to start, we need to install Deno and this task is very easy for any operating system. See more at https://deno.land/#installation.

Deno is a command-line program. After its installation, you can get using the following commands to help you start works with it.

$ deno help

$ deno --h

$ deno --help

To launch a Deno app you need simply use at the command line:

$ deno run <entry-point>

This entry point can be a JavaScript (.js) file or TypeScript (.ts) file. But the great news is the possibility to use a URL that points to an app entry point.

Deno’s website provides some examples, like these.

Let’s run it to see what happens.

$ deno run https://deno.land/std/examples/welcome.ts
Download https://deno.land/std/examples/welcome.ts
Compile https://deno.land/std/examples/welcome.ts
Welcome to Deno 🦕

Deno downloaded the welcome.ts file, and compiled it, and ran it. If we run the app again, Deno will just run it, because it’s cached by Deno.

$ deno run https://deno.land/std/examples/welcome.ts
Welcome to Deno 🦕

Deno downloads all the modules and caches them. It will not download them again until you specifically request them with the reload flag.

$ deno run --reload https://deno.land/std/examples/welcome.ts
Download https://deno.land/std/examples/welcome.ts
Compile https://deno.land/std/examples/welcome.ts
Welcome to Deno 🦕

And the best so far is that when Deno runs the app, it only compiled the TypeScript file, that is, we don’t need to use any transpiler for that.

It happens because Deno supports Typescript out of the box.

EcmaScript modules vs. CommonJS

Deno uses the last ECMAScript features in its API and libraries and because of the native support of ES Modules in Deno you don’t have to use other build tools to make your application ready to use in a browser.

Deno supports ES Modules, instead of the CommonJS syntax used by Node. As a result, dependency management is very simple and flexible and it just uses a local or remote URL, but it provides compatibility with Node too.

For example, require functions (require()) is not supported. The ES Modules standard syntax uses the import statement for that (import defaultExport from "module-name").

To load CommonJS modules you can use createRequire(...), like the example below.

import { createRequire } from "https://deno.land/std/node/module.ts";

const require = createRequire(import.meta.url);
// Loads native module polyfill.
const path = require("path");
// Loads extensionless module.
const cjsModule = require("./my_mod");
// Visits node_modules.
const leftPad = require("left-pad");

More details about that and examples like this can be seen at the link https://deno.land/std/node.

As we saw earlier, we can use a URL as an entry point to run a Deno application. And as we can also use a local or remote URL to manage the dependencies I created a repository on GitHub to send some examples from Deno and I can simply import dependencies from there.

I simply created a file called hello.ts that imports a welcome.ts function that prints the same standard greeting message that we used in the previous examples.

Let's see below the content of hello.ts.

import { welcome } from 'https://github.com/jaquiel/deno-features/raw/master/std/welcome.ts'

welcome()

Now, the result of running the app.

$ deno run hello.ts
Compile file:///C:/Users/jaquiel/Documents/vscode/deno/deno-features/std/hello.ts
Download https://github.com/jaquiel/deno-features/raw/master/std/welcome.ts
Download https://raw.githubusercontent.com/jaquiel/deno-features/master/std/welcome.ts
Welcome to Deno 🦕

It's really very easy and simple to work with Deno.

Security

As previously seen, in Deno's own documentation it is defined as a secure runtime for JavaScript and TypeScript. To access to security-sensitive areas or functions, you must use permissions on the command line.

Let's see an example of the Deno website.

Running without using the --allow-net flag we will get the following result.

$ deno run https://deno.land/std/examples/echo_server.ts
error: Uncaught PermissionDenied: network access to "0.0.0.0:8080", run again with the --allow-net flag
    at unwrapResponse ($deno$/ops/dispatch_json.ts:43:11)
    at Object.sendSync ($deno$/ops/dispatch_json.ts:72:10)
    at Object.listen ($deno$/ops/net.ts:51:10)
    at Object.listen ($deno$/net.ts:152:22)
    at https://deno.land/std/examples/echo_server.ts:4:23

We can see that we had a permission denied error. But if we use the flag the app will run without any problem.

$ deno run --allow-net https://deno.land/std/examples/echo_server.ts
Listening on 0.0.0.0:8080

In the link https://deno.land/manual/getting_started/permissions#permissions-list , we can see the detailed list of all available permissions.

Conclusion

Well, my goal wasn’t to explain Deno's features to you, because the documentation can help you understand it easily. Rather, I just wanted to try these advantages in practice.

I reiterate my opinion that Node.js will not die and will not be replaced by Deno, because it is a well-established technology that will certainly remain for many years and, in addition, its own creator developed Deno only as an alternative to Node, and not as a replacement.

Finally, although I believe in a long life for Node I can't help saying that the new Deno’s features are truly exciting and it is, likely, the new Hype.