Snowstorm - Local Snomed CT terminology server

If you want to do some development against Snomed CT terminology server, you can download Snowstorm, an open source terminogy server with support for Snomed CT. It is primarily written in Java and built on top of ElasticSerach. The easiest way of getting Snowstorm running in your local development server (or on an actual server if desired), is to download the Docker images for Elasticsearch and Snowstorm. I have added a Yaml file on my Github repo for installing both Elasticsearch and Snowstorm here:

docker-compose.yml
docker-compose.yml

The Yaml file sets up the following for Elastsearch and Snowstorm :

Elasticsearch

• Sets up Elasticsearch as a service that Snowstorm depends upon on port 9200
• Pulls Elasticsearch version 8.19.8. You obviously want to test out even newer versions of Elasticsearch later on
• Sets up a durable volume for Elasticseachon elastic:/usr/share/elasticsearch/data
• Snomed depends upon Elasticsearch and the condition must be healthy of Elasticsearch from the healthchecks
• Memory reservation is set to 4 GB for ElasticSearch
• Since in this example Elasticsearch is set up to run in LocalDEV, xpack.security.enabled is set to false. This turns off authorization, authentication, TLS and audit since the example setup in this docker compose file is meant for development environments, not for production.

Snowstorm

• Sets up Snowstorm to use Elasticsearch as a service on port 9200
• Snowstorm is set up to run on 8080 (HTTP)
• A bind mount is set up on ./rf2 that is on the host computer and mapped to the ./rf2 folder in the container. We use this bind mount to import the Rf2 file later on

docker-compose.yml

# https://github.com/IHTSDO/snowstorm/blob/master/docker-compose.yml

services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.19.8
    container_name: elasticsearch
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
      - node.name=snowstorm
      - cluster.name=snowstorm-cluster
      - "ES_JAVA_OPTS=-Xms4g -Xmx4g"
    volumes:
      - elastic:/usr/share/elasticsearch/data
    networks:
      elastic:
        aliases:
         - es
    healthcheck:
      test: ["CMD", "curl", "-f", "http://es:9200"]
      interval: 1s
      timeout: 1s
      retries: 60
    ports:
      - 127.0.0.1:9200:9200
    mem_reservation: 4g

  snowstorm:
    image: snomedinternational/snowstorm:latest
    depends_on:
      elasticsearch:
        condition: service_healthy
    environment:
      - elasticsearch.urls=http://elasticsearch:9200
      - JAVA_TOOL_OPTIONS=-Xms2g -Xmx4g --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED
    command: [
      "--elasticsearch.urls=http://es:9200",
    ]
    networks:
      elastic:
        aliases:
         - snowstorm
    ports:
      - "8080:8080"
    volumes:
      - ./rf2:/rf2

networks:
  elastic:
    name: elastic

volumes:
  elastic:

A component diagram (UML) of the Rf2 format is shown below. Note that RefsetItem is extensible and contain additional fields depending on the refset type.

Obtaining Rf2 files with Snomed Ct for Snowstorm

One way of obtaining Snomed Ct Rf2 files is to head over to National Clinical Terminology Service (NCTS) in Australia. They offer individual access to Snomed CT Rt2 files after a quick registration.
The Digital Health Implementer Hub has a Native Snomed Ct Rf2 file page here. Note that this comes with the Australian Snomed CT-AU bundle, but includes the International core terminology data set. https://implementer.digitalhealth.gov.au/ncts/native-snomed-ct-rf2-files This page has an entity relationship diagram shown below for the Rf2 data: One tip concerning uploading a backup of the Rf2 file to Github is to use 7-zip and split up the volume into multiple files. You can upload 100 MB in maximum file sizes to Github. The Snomed Ct-AU file is about 890 MB as of November 2026. When you have the Rf2 files uploaded to the folder Rf2, a subdir of where you started the docker compose yaml file, make sure the Rf2 folder contains the .Zip file with the Rf2 file containing the Snomed CT file to import into the Snowstorm service running with Elasticsearch.

Starting up Snowstorm

Navigate to the folder where we have the docker-compose.yml file and just start up the Docker compose file. Start up Docker for Desktop to be sure Docker service is running.

Please note that when doing the import, it can be easier to view all the logs if running the docker command from the command line. You can see the Logs inside Docker Desktop, but the commandline will be more verbose. As noted, make sure you have the Rf2 subfolder. The bat file below contains a small script that will copy the extracted ALL zip file (you will have to obtain the Rf2 file yourself due to the fact it requires registration), so adjust the folder and file.

CopySnomedInternationalRf2.bat

mkdir rf2
cd rf2
xcopy C:\src\Snowstorm.Snowmed.Rf2_International_Distribution\NCTS_SCT_RF2_DISTRIBUTION_32506021000036107-20261031-ALL.zip .

To get Snowstorm up and running with Elasticsearch, just run this command (note that the first time, Docker images will be pulled for Snowstorm and Elasticsearch, so it will take some time until they are downloaded :

docker compose up

The containers are spinning up rather quickly and you can switch over to Docker Desktop via the "v" shortcut.

Opening up the Swagger page for Snowstorm

The Swagger page is opened up at http://localhost:8080 when the containers are running. The next step now is to import the Snomed Ct Rf2 file. The following Powershell script can be used to import the Rf2 file. Adjust it with the Rf2 file you got. But we have downloaded the FULL Snomed-CT AU file here , so make sure you set the 'type' to FULL !

StartImportNctsSctRf2.ps1

The Powershell script below POST the Rf2 file to the imports/start-local-file-import endpoint. The upload will usually take 15-30 minutes. Since the docker-compose.yml has set up a volume, you do not have to do this everytime. The container got a volume for persistence.

$body = @{
    branchPath = "MAIN"
    filePath = "/rf2/NCTS_SCT_RF2_DISTRIBUTION_32506021000036107-20261031-ALL.zip"
    type = "FULL"
    createCodeSystemVersion = $true
} | ConvertTo-Json

Write-Host $body

Write-Host Starting import...

$response = Invoke-RestMethod `
    -Uri "http://localhost:8080/imports/start-local-file-import" `
    -Method Post `
    -ContentType "application/json" `
    -Body $body


Write-Host Retrieving response from the start-local-file-import
$response | ConvertTo-Json -Depth 10

Snomed Ct Codes - Validation using Verhoeff algorithm

In this article, an algorithm for validating Snomed Ct codes using a control digit will be presented. The source code in this article is available in my Github repo here :
🕸️https://github.com/toreaurstadboss/SnomedCtTools

Snomed Ct stands form Systemized Nomenclature Of MEDicine - Clinical Terms It is an international standard of terminology used in Electronic Health Records (EHR), also known as patient journals. It has also national extensions in addition to its shared 370,000 items. Norway for example has 16,000 national (local) items.

To validate Snomed Ct codes we use the Verhoeff algorithm.

The Verhoeff algorithm calculates a checksum for error detection. Snomed Ct codes use the algorithm for the checksum, which is the last digit in its code. It was first published in 1969 by Dutch matematician Jacobus Verhoeff. It was also discovered much later by German matematician Peter Gumm in 1985, which then included a formal proof
in addition. The theory is based upon Group theory. The algorithm detects all single digit errors (one digit wrong) or format errors, one digit inserted or left out or transpositions (interchanging two adjacent digits). The research paper is here:

👉🏻 https://www.researchgate.net/publication/3084126_A_new_class_of_check-digit_methods_for_arbitrary_number_systems_Corresp

An easier overview of the algorithm is exaplained on the Wikipedia article of Verhoeff algorithm: 📖 https://en.wikipedia.org/wiki/Verhoeff_algorithm

First off we consider a multiplication table for the algorithm, D. It is also called the Cayley table, more description on that in the following Wikipedia page:

📗 https://en.wikipedia.org/wiki/Cayley_table. The Cayley table of the Dihedral group D5 is used in the Verhoeff algorithm.

VerhoeffValidator.cs - Multiplication matrix P - Cayley table D of Dihedral (5 sided polygon) Group D5

  private static readonly int[,] D =
  {
      { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
      { 1, 2, 3, 4, 0, 6, 7, 8, 9, 5 },
      { 2, 3, 4, 0, 1, 7, 8, 9, 5, 6 },
      { 3, 4, 0, 1, 2, 8, 9, 5, 6, 7 },
      { 4, 0, 1, 2, 3, 9, 5, 6, 7, 8 },
      { 5, 9, 8, 7, 6, 0, 4, 3, 2, 1 },
      { 6, 5, 9, 8, 7, 1, 0, 4, 3, 2 },
      { 7, 6, 5, 9, 8, 2, 1, 0, 4, 3 },
      { 8, 7, 6, 5, 9, 3, 2, 1, 0, 4 },
      { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 }
  };

The permutations table P is applying permutations for the numbers 0-9 iteratively with the permutation (1 5 8 9 4 2 7 0)(3 6) We end up with an iterative mapping of permutations for each row

1 -> 5 -> 8 -> 9
^              |
|              v
0 <- 7 <- 2 <- 4

3 <-> 6

VerhoeffValidator.cs - Permutations matrix P

  private static readonly int[,] P =
  {
      { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
      { 1, 5, 7, 6, 2, 8, 3, 0, 9, 4 },
      { 5, 8, 0, 3, 7, 9, 6, 1, 4, 2 },
      { 8, 9, 1, 6, 0, 4, 3, 5, 2, 7 },
      { 9, 4, 5, 3, 1, 2, 6, 8, 7, 0 },
      { 4, 2, 8, 6, 5, 7, 3, 9, 0, 1 },
      { 2, 7, 9, 3, 8, 0, 6, 4, 1, 5 },
      { 7, 0, 4, 6, 9, 1, 3, 2, 5, 8 }
  };

The Verhoeff validation check then becomes the following method, where we perform an algorithm that does the following calculation for the checksum c :

VERHOEFF ALGORITHM - CHECKSUM CALCULATION

1. Create an array n from the digits of the number, read right to left (rightmost digits become n_0 and so on) - i.e. reversal of the digits
2. Initialize the checksum c to zero :    c = 0.
3. For each index i of the array n, starting at zero, replace c with the following : 
   D(c, P(i mod 8, n_i))          


Note that the calculations here uses  array lookup of D and P. The mod here is the standard modulo operator, % , n_i is the n-th element.

4. Check that the final value of c is 0 : 
   c = 0  

  /// <summary>
    /// Checks whether a number has a valid Verhoeff check digit.
    /// </summary>
    /// <param name="number">The numeric identifier, including its check digit.</param>
    /// <returns><see langword="true" /> when the number passes the Verhoeff check.</returns>
    public static bool IsValidVerhoeff(string code)
    {
        int[] digits = code
            .Select(character => int.Parse(character.ToString()))
            .Reverse()
            .ToArray();
        int checksum = 0;

        for (int index = 0; index < digits.Length; index++)
        {
            checksum = D[checksum, P[index % 8, digits[index]]];
        }

        return checksum == 0;
    }

A more mathematical formulation :

VERHOEFF CHECKSUM VALIDATION

Let n = (n₀, n₁, ..., nₖ₋₁) denote the digits of the identifier in reverse order,
where n₀ is the rightmost digit.

Initialize

    c₀ = 0

For each position i = 0, ..., k − 1 compute

    cᵢ₊₁ = D(cᵢ, P(i mod 8, nᵢ))

where

    D : {0,...,9} × {0,...,9} → {0,...,9}

is the Cayley table derived from the dihedral group D₅, and

    P : {0,...,7} × {0,...,9} → {0,...,9}

is the position-dependent digit permutation.

The identifier is valid if and only if

    cₖ = 0.

Snomed Ct validator

Snomed Ct codes validates in addition that the code is numerical (only digits) and has a length between 6 to 18 digits. Our validator will accept whitespace and normalizes the code be removing whitespace.

using System.Text.RegularExpressions;

namespace SnomedCtTools.Lib.Validation;


public static class SnomedCtValidator
{

    /// <summary>
    /// Checks if a Snomed Ct Code is valid.
    /// It should be :
    /// - 6 to 18 digits
    /// - All numerics (this method washes away whitespace anyways)
    /// - Passes the Verhoeff's dihedral check, which is checked by this 
    /// method internally.
    /// </summary>
    /// <param name="code"></param>
    /// <returns></returns>
    public static bool IsValidSnomedCt(string code)
    {
        if (string.IsNullOrWhiteSpace(code))
        {
            return false;
        }
        //normalize whitespace to allow flexibility concerning whitespace
        string normalizedCode = Regex.Replace(code, @"\s+", "");
        if (!normalizedCode.All(c => char.IsDigit(c)))
        {
            return false;
        }

        if (normalizedCode.Length < 6 || normalizedCode.Length > 18)
        {
            return false;
        }

        bool isValid = VerhoeffValidator.IsValidVerhoeff(normalizedCode);
        return isValid;
    }

}

Some unit tests validates well known Snomed Ct codes and also checks that erroneous codes are flagged as not valid code. This is done by looking at the last digit, which is the checksum and using the Verhoeff algorithm and checking we are between 6-18 digits in length as noted. And also, we normalize and remove whitespace to offer some flexibility.

using FluentAssertions;
using NUnit.Framework;
using SnomedCtTools.Lib.Validation;

namespace SnomedCtTools.Tests.Validation
{

    [TestFixture]
    public class SnomedCtValidatorTests
    {

        [Test]
        [TestCase("44054006", true, Description = "diabetes type 2")]
        [TestCase("440540006", false, Description = "not a snomed ct code")]
        [TestCase("67148009", true, Description = "Podagra")]
        [TestCase("671480091", false, Description = "not a snomed ct code")]
        public void SnomedCtValidationCheckForWellknownDiseases(string code, bool expected)
        {
            SnomedCtValidator.IsValidSnomedCt(code).Should().Be(expected);
        }

        [Test]
        [TestCase("24700007", true)]
        [TestCase("2470", false)]
        [TestCase("2470000000000000000000000000007", false)]
        public void SnomedCtValidationChecksLengthCorrect(string code, bool expected)
        {
            SnomedCtValidator.IsValidSnomedCt(code).Should().Be(expected);
        }

        [Test]
        [TestCase("24700007", true)]
        [TestCase(" 24700007", true)]
        [TestCase("24700007 ", true)]
        [TestCase("2470 0007  ", true)]
        [TestCase("2  470 00  07  ", true)]
        public void SnomedCtValidationAcceptsWhiteSpace(string code, bool expected)
        {
            SnomedCtValidator.IsValidSnomedCt(code).Should().Be(expected);
        }

        [Test]
        [TestCase("24700007", true)]
        [TestCase("k24700007", false)]
        [TestCase("24700007#", false)]
        [TestCase("2470@k0007kk", false)]
        [TestCase("2kk3k#@!470###00kk07ll", false)]
        public void SnomedCtValidationCheckIlleagalChars(string code, bool expected)
        {
            SnomedCtValidator.IsValidSnomedCt(code).Should().Be(expected);
        }

    }

}

Generating a checksum for an arbitrary new Snomed code

The updated version of VerhoeffValidator.cs below includes another method that calculates the control digit. The Algorithm for the Verhoeff control digit is as follows.

VERHOEFF CHECKSUM GENERATION

Given input n of length k, n_k, append the digit 0 at the end to give 
a new input of n_k+1

Let n_k+1 = (n₀, n₁, ..., nₖ) where n_k = 0 ,  denote the digits of the identifiers, the elements are then 
reversed in order,
where n₀ is the rightmost digit (0)

Initialize

    c₀ = 0

For each position i = 0, ..., k − 1 compute

    cᵢ₊₁ = D(cᵢ, P(i mod 8, nᵢ))

where

    D : {0,...,9} × {0,...,9} → {0,...,9}

is the Cayley table derived from the dihedral group D₅, and

    P : {0,...,7} × {0,...,9} → {0,...,9}

is the position-dependent digit permutation.

The identifier is valid if and only if

    cₖ = 0.
    
The generated checksum digit then is the lookup using c of the multiplicative inverse of a digit in J.
    

As shown earlier, this is similar to the Verhoeff validation algorithm, but we append 0 at the end and then run the Verhoeff algorithm to yield the Verhoeff control digit at the end. It is this checksum that then is to be appended to the code with the Verhoeff control digit to get the correct Snomed code. The updated code below shows some additional optimizations of using byte and char datatypes and the added method to generate Verhoeff control digit.

namespace SnomedCtTools.Lib.Validation;

/// <summary>
/// Validates numeric identifiers using the Verhoeff check digit algorithm.
/// </summary>
public static class VerhoeffValidator
{
    /// <summary>
    /// Checks whether a number has a valid Verhoeff check digit.
    /// </summary>
    /// <param name="number">The numeric identifier, including its check digit.</param>
    /// <returns><see langword="true" /> when the number passes the Verhoeff check.</returns>
    public static bool IsValidVerhoeff(string code)
    {
        int checksum = CalculateChecksum(code);
        return checksum == 0;
    }  

    /// <summary>
    /// Generates the Verhoeff digit, which is the check digit to be appended to code
    /// </summary>
    /// <param name="code"></param>
    /// <returns></returns>
    public static char GenerateVerhoeff(string code)
    {
        string normalizedCode = code + "0";
        int checkSum = CalculateChecksum(normalizedCode);
        string checkDigit = J[checkSum].ToString();
        return checkDigit[0];
    }

    private static readonly byte[,] D =
    {
        { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
        { 1, 2, 3, 4, 0, 6, 7, 8, 9, 5 },
        { 2, 3, 4, 0, 1, 7, 8, 9, 5, 6 },
        { 3, 4, 0, 1, 2, 8, 9, 5, 6, 7 },
        { 4, 0, 1, 2, 3, 9, 5, 6, 7, 8 },
        { 5, 9, 8, 7, 6, 0, 4, 3, 2, 1 },
        { 6, 5, 9, 8, 7, 1, 0, 4, 3, 2 },
        { 7, 6, 5, 9, 8, 2, 1, 0, 4, 3 },
        { 8, 7, 6, 5, 9, 3, 2, 1, 0, 4 },
        { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 }
    };

    private static readonly byte[,] P =
    {
        { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
        { 1, 5, 7, 6, 2, 8, 3, 0, 9, 4 },
        { 5, 8, 0, 3, 7, 9, 6, 1, 4, 2 },
        { 8, 9, 1, 6, 0, 4, 3, 5, 2, 7 },
        { 9, 4, 5, 3, 1, 2, 6, 8, 7, 0 },
        { 4, 2, 8, 6, 5, 7, 3, 9, 0, 1 },
        { 2, 7, 9, 3, 8, 0, 6, 4, 1, 5 },
        { 7, 0, 4, 6, 9, 1, 3, 2, 5, 8 }
    };

    private static readonly int[] J =
    {
        0,4,3,2,1,5,6,7,8,9
    };

    private static byte CalculateChecksum(string code)
    {
        byte[] digits = code
                    .Select(character => byte.Parse(character.ToString()))
                    .Reverse()
                    .ToArray();
        byte checksum = 0;

        for (int index = 0; index < digits.Length; index++)
        {
            checksum = D[checksum, P[index % 8, digits[index]]];
        }
        return checksum;
    }

}

We also have some tests that then can test the control digit generation.

using FluentAssertions;
using NUnit.Framework;
using SnomedCtTools.Lib.Validation;

namespace SnomedCtTools.Tests.Validation
{

    [TestFixture]
    public class SnomedCtValidatorTests
    {

        [Test]
        [TestCase("44054006", true, Description = "diabetes type 2")]
        [TestCase("440540006", false, Description = "not a snomed ct code")]
        [TestCase("67148009", true, Description = "Podagra")]
        [TestCase("76148009", false, Description = "not a snomed ct code")]
        public void SnomedCtValidationCheckForWellknownDiseases(string code, bool expected)
        {
            SnomedCtValidator.IsValidSnomedCt(code).Should().Be(expected);
        }

        [Test]
        [TestCase("4405400", "44054006", Description = "diabetes type 2")]
        [TestCase("4405k40006", null, Description = "not a valid snomed ct code")]
        [TestCase("6714800", "67148009", Description = "Podagra")]
        [TestCase("-671480091", null, Description = "not a snomed ct code")]
        [TestCase("5079700", "50797007", Description = "Bubonic plague")]
        [TestCase("2807200", "28072004", Description = "Cauliflower ear / Blomkåløre")]
        public void SnomedCtValidationAppendsCorrectCheckDigit(string code, string expected)
        {
            SnomedCtValidator.GenerateSnomedCtCode(code).Should().Be(expected);
        }

        [Test]
        [TestCase("24700007", true)]
        [TestCase("2470", false)]
        [TestCase("2470000000000000000000000000007", false)]
        public void SnomedCtValidationChecksLengthCorrect(string code, bool expected)
        {
            SnomedCtValidator.IsValidSnomedCt(code).Should().Be(expected);
        }

        [Test]
        [TestCase("24700007", true)]
        [TestCase(" 24700007", true)]
        [TestCase("24700007 ", true)]
        [TestCase("2470 0007  ", true)]
        [TestCase("2  470 00  07  ", true)]
        public void SnomedCtValidationAcceptsWhiteSpace(string code, bool expected)
        {
            SnomedCtValidator.IsValidSnomedCt(code).Should().Be(expected);
        }

        [Test]
        [TestCase("24700007", true)]
        [TestCase("k24700007", false)]
        [TestCase("24700007#", false)]
        [TestCase("2470@k0007kk", false)]
        [TestCase("2kk3k#@!470###00kk07ll", false)]
        public void SnomedCtValidationCheckIlleagalChars(string code, bool expected)
        {
            SnomedCtValidator.IsValidSnomedCt(code).Should().Be(expected);
        }

    }

}

The tests passes !

Start up nginx Docker container and edit homepage

This article will be a quick tip how to get a web server up and running on your system, in this case using Docker image nginx to spin up a container. First off, install Docker. To install docker:

• The Docker website contains the container software you need to quickly spin up nginx. You need an account there, you can use for example a Google account to log in and create the account
• You probably want to use for just experimentation the Personal plan, which is free. Go to https://docs.docker.com/get-started/get-docker/
• Install Docker for Desktop for your OS - Linux, Windows or Mac

To get nginx up and running, do the following commands from the command line, after Docker is installed and Docker for Desktop has been started. This will make sure the Docker background system processes are running (Docker deaemon).

docker command (CLI)
        │
        ▼
Docker daemon (dockerd)
        │
        ├─ Creates containers
        ├─ Pulls images
        ├─ Creates networks
        ├─ Manages volumes
        └─ Starts/stops containers
        
 

Links to Nginx and Docker hub Nginx image

https://nginx.org

The docker hub image for nginx is here, it has been downloaded a billion times plus.

https://hub.docker.com/_/nginx

Getting nginx running on your system

First off we start the nginx image (it will be pulled the first time and downloaded, then cached later on). It is run as a daemon background service with -d. nginx will run at port 8080 to avoid conflicting with other services running at port 80 such as IIS web server. The nginx project's homepage is here:

docker run -d --name nginx_test -p 8080:80 nginx

Here, we name the container as nginx_test The system prompts back the container id We can also see the containers running image with name nginx like this :

docker ps --filter ancestor=nginx

CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS          PORTS                                     NAMES
a2cc9ed9b212   nginx     "/docker-entrypoint.…"   12 minutes ago   Up 12 minutes   0.0.0.0:8080->80/tcp, [::]:8080->80/tcp   nginx_test
ea3bf3541852   nginx     "/docker-entrypoint.…"   12 hours ago     Up 12 hours     80/tcp                                    container-b
505eec83cca5   nginx     "/docker-entrypoint.…"   12 hours ago     Up 12 hours     80/tcp   

In this case, I tested some nginx containers some hours ago and they are still running. We can stop containers by running docker stop <container-id> Our nginx_test container is now running, we can enter the container next.

docker exec -it nginx_test bash

The Linux OS that is running inside the nginx container has no editor installed, not even vim og vi (it is optimalized to use minimal disk space so it got the bare minimum to run the web server nginx itself). Lets install nano to edit files inside the container!

apt-get update
apt-get install nano

The homepage of nginx is installed in /usr/share/nginx/html Edit the index.html file by running nano . nano index.html

cd /usr/share/nginx/html
nano index.html

You can save the index.html file after editing in nano by entering Ctrl+O and write to the file.

Additional notes

This is just for testing out nginx. To stop all containers on your system for example, you can either exit out of Docker for desktop or run this command (Powershell, other OS-es got similar command):

docker stop $(docker ps -q)

This will output the container ids of what was stopped. Afterwards, you can check that no containers are running using this:

docker ps

You should see an empty list of containers, i.e. no containers running on your system.

 ~#@❯ docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES

Just to note, if you are to run nginx on a server you most definately want to enable a drive for your container, for durability. But for now, this article was just a short article how to get a web server such as nginx up and running on your system and play around with Docker. Windows Users - Please note Docker takes much resources, so to stop Docker in Windows and if you run the default setup of using WSL2 containers, this command should stop Docker. You can start up Docker again by just running Docker Desktop again.

wsl --shutdown
taskkill /F /IM "Docker Desktop.exe"