DEV Community: abdulrahilsheikh

Fixing HTTPS Certificates in .NET Dev Containers (The Right Way)

abdulrahilsheikh — Thu, 08 Oct 2026 11:17:13 +0000

Project Directory Structure
Before we dive into the commands, here is what your repository layout looks like, showing where the .NET backend code resides under the server/ folder and where the generated certificate will live:

dotnet_learning/
├── .devcontainer/
│   ├── devcontainer.json
│   └── docker-compose.yml
├── server/                    <-- .NET Backend Project Folder
│   ├── certs/
│   │   └── localhost.pfx      <-- Generated & mounted PFX certificate
│   ├── Controllers/
│   ├── Program.cs
│   └── Server.csproj
├── next_ui/                   <-- Frontend (React/Next.js)
└── README.md

The Problem: Certificates in Isolated Environments

When you spin up a Dev Container, it runs inside an isolated Linux environment (usually Debian or Ubuntu). Your host machine's trusted certificate store isn't automatically shared with the container.

If you try to run the standard .NET certificate command:

dotnet dev-certs https --trust

It might fail or fail to persist outside the container lifecycle, leaving your browser or API clients complaining about untrusted certificates (ERR_CERT_AUTHORITY_INVALID).

Step 1: Clean the Slate (Just in Case)

If you've been messing around with existing certificates and hitting weird errors, start by clearing out any corrupted state:

dotnet dev-certs https --clean

(Note: If you run into a strange Interop.Sys.GetCwdHelper error on macOS/Linux while doing this, it usually means your terminal's current working directory got unlinked. Simply run cd ~ && cd - to reset your shell's path, then try again).

Step 2: Generate and Export a `.pfx` Certificate

Instead of relying solely on the container's auto-generated store, you can explicitly export a password-protected .pfx file from your host machine that you can mount into your container.

Open your terminal, make sure you are in your project's root folder (workspace root). Run the following command on your host machine to generate the cert and save it inside your project's server/certs/ folder:

dotnet dev-certs https -ep ./server/certs/localhost.pfx -p "Password"

-ep ./server/certs/localhost.pfx: Exports the certificate to your project path.
-p "Password": Sets a password to protect the private key inside the PFX bundle.

Step 3: Trust the Certificate inside the Container

Right after generating your certificate runn the below command, to make sure your host machine trusts the development certificate so your browser and host tools don't throw security errors:

dotnet dev-certs https --trust

(Note: Depending on your OS—macOS, Windows, or Linux—this will prompt you for your user password or system administrator permissions to install the development certificate into your host's trusted root authority store.)

Step 4: Configure it in your `devcontainer.json`

To make your container use this certificate automatically, you need to configure two things in your .devcontainer/devcontainer.json:

mounts: To bind-mount the .pfx file from your host into the container's file system (e.g., /certs/localhost.pfx).
containerEnv: To tell Kestrel where to find the certificate using ASP.NET Core environment variables.

Here is how your devcontainer.json should look with the certificate mounts and environment configurations injected:

// For format details, see https://aka.ms/devcontainer.json. For config options, see the
// README at: https://github.com/devcontainers/templates/tree/main/src/dotnet-postgres
{
    "name": "C# (.NET) and PostgreSQL",
    "dockerComposeFile": "docker-compose.yml",
    "service": "app",
    "workspaceFolder": "/workspaces/${localWorkspaceFolderBasename}",
    "features": {
        "ghcr.io/devcontainers/features/node:2": {
            "nodeGypDependencies": true,
            "version": "lts",
            "npmVersion": "lts",
            "pnpmVersion": "latest",
            "nvmVersion": "latest"
        }
    },
    "mounts": [
        "source=node_modules_vol,target=${containerWorkspaceFolder}/next_ui/node_modules,type=volume",
        // Mount your generated PFX certificate into the container
        "source=${localWorkspaceFolder}/server/certs/localhost.pfx,target=/certs/localhost.pfx,type=bind"
    ],
    "customizations": {
        "vscode": {
            "extensions": [
                "ms-dotnettools.csharp",
                "ms-dotnettools.cs-dev-kit"
            ]
        }
    },
    "postCreateCommand": "sudo chown -R vscode:vscode /workspaces/dotnet_learning/next_ui/node_modules || true",

    // Configure Kestrel to use the mounted certificate via environment variables
    "containerEnv": {
        "ASPNETCORE_Kestrel__Certificates__Default__Path": "/certs/localhost.pfx",
        "ASPNETCORE_Kestrel__Certificates__Default__Password": "Password",
    }
}

Wrapping Up

Handling SSL certificates in Docker containers can be frustrating, but by generating a .pfx file on your host, binding it via mounts, and configuring Kestrel through containerEnv, your .NET app will run smoothly with fully trusted HTTPS inside your Dev Container!

Creating an Express.js App Using Typescript & MongoDb P-1

abdulrahilsheikh — Wed, 05 Jul 2023 10:38:18 +0000

Section 1 - Creating Express App

Step by step Implementation:
Step 1 : First create a empty folder and open terminal in this folder.

Step 2 : Run the following command in your terminal, to create a nodejs application, because our express server will work inside the node application.
Command :

npm init

Step 3 : Installing all the necessary dependencies for our application.

Command :

npm install express cors mongoose

Step 4 : Now we need to install types for express and cors.

npm install @types/express @types/cors --save-dev

Step 5 : Now we have to set up typescript for our app for that run the following command
Command :

tsc --init

This will create a tsconfig.json file which will have all the configuration for the typescript.

Step 6 : Now to run the typescript application we need to install some additional dependencies. Which are ts-node and nodemon.
Command :

npm i nodemon ts-node --save-dev

After following all the steps your folder structure should look like

-|-node_modules
 |-package-lock.json
 |-package.json
 |-tsconfig.json

Step 7 : Creating an entry point for our express app to start.
create an index,ts file in the root of your project. Also create a folder with app name here we will put all of our middleware, routes etc.

The project structure will look like following.

-|-app
 |-node_modules
 |-index.ts
 |-package-lock.json
 |-package.json
 |-tsconfig.json

Step 8: To run the server we need to add following script to our package.json file. Also change the extension on index.js to index.ts of the main property in package.json.

"run:dev": "nodemon index.ts"

After this our script will look like

Step 9: Now to test our setup is working file put the below code snippet in the index.ts.

console.log("I'm running")

Now in the terminal run the following command

npm run run:dev

The text I'm running should log in the terminal and your terminal should look like following.

Hurray 🎉🎊🎉 we have successfully setup our starting point

Step 10: Now create a app.ts file in app folder. The folder structure will look like following.

-|-app
 |   |-app.ts
 |-node_modules
 |-index.ts
 |-package-lock.json
 |-package.json
 |-tsconfig.json

Step 11: Now need to create our express server. For that we need an instance of express. For that we need to import express from express package we installed. for that put the below code at the top of app.ts file.
And now invoke this express function imported and store it into a variable named app

import express from "express";

const app: express.Application = express();

express.Application will give us typescript interface of express

Now create a function named server and export it. We will use this server function in index.ts.

import express from "express";

const app: express.Application = express();
export const server = async () => {
    const port: number = 3500;
    app.listen(port, () => {
        console.log(`Server running on ${port}`);
    });
};

Now in index.ts import the server and invoke it as shown below.

import { server } from "./app/app";

server();

Now again run the npm run run:dev to start the server in dev mode.

npm run run:dev

Your terminal will look like following.

Step 12: Now we will create a basic get route which will return hello world. For doing first we will create an organized folder structure . For that we will create a modules folder inside our app folder for holding our routes. In this modules folder create a new folder called users. Inside it create files called users.routes.ts, users.schema.ts and users.services.ts . Now you folder should look like following.

-|-app
 |   |-modules
 |   |    |-users
 |   |       |-users.routes.ts
 |   |       |-users.schema.ts
 |   |       |-users.services.ts
 |   |-app.ts
 |-node_modules
 |-index.ts
 |-package-lock.json
 |-package.json
 |-tsconfig.json

Each file has its own role.

users.routes.ts will hold all the routes such as get, post, patch etc.
users.schema.ts will hold the mongoose schema and model which we will use to communicate with mongodb.
users.services.ts will hold the all function which we need to complete or process the user request.

Step 13: In user.routes.ts import the Router from express and create an instance of it.
Router function is used to create a new router object which is used to create a new router object in your program to handle requests.
Your code should look like below.

import { Router } from "express";

const userRouter = Router();

userRouter.get("/users", (req, res) => {
    res.json({ message: "sent succesfully" });
});

export default userRouter;

Now import this user router in your app.ts file and use is as shown below.

import express from "express";
import userRouter from "./modules/users/users.routes";

const app: express.Application = express();
export const server = async () => {
    const port: number = 3500;
    app.use('/',userRouter);
    app.listen(port, () => {
        console.log(`Server running on ${port}`);
    });
};

Now in your browser go to http:localhost:3500/users or whatever your port is http:localhost:/users.
You will see the following.

Congratulations 🎊🎉 you've successfully created a route. You can similarly create a post route.

Now we will use the services file.
The services file will have all the business logic like processing data, fetching from db etc.
In users.services.ts paste the following code block.

const users = [
    { name: "Jhon Doe", age: 24 },
    { name: "Man Freed", age: 22 },
    { name: "Mr Beast", age: 21 },
    { name: "Carry Minati", age: 25 },
];

export const getRandomUser = () => {
    const index = Math.floor(Math.random() * users.length);
    return users[index];
};

Also modify the user.routes.ts like the following.

import { Router } from "express";
import { getRandomUser } from "./users.services";

const userRouter = Router();

userRouter.get("/users", (req, res) => {
    const user = getRandomUser();
    res.json({ user });
});

export default userRouter;

Now each time you hit "/users" or refresh the page in browser you will get a different user.
We will be using this services a lot when dealing with mongodb.

For connecting to mongodb and using it we will have another blog.