Docker Local Deployment
    (Created page with " Create a docker file for the MDriven Server Contents of ''<u>MDrivenServer.Dockerfile</u>''<syntaxhighlight lang="dockerfile"> # syntax=docker/dockerfile:1 FROM mcr.microsoft.com/dotnet/sdk:8.0-alpine RUN apk add --upgrade --no-cache \ curl \ unzip \ xmlstarlet WORKDIR /app ARG MS_VERSION RUN curl -O https://mdriven.net/PublicDownloads/MDrivenServerOnCoreVersion.xml \ && MS_VERSION=$(xmlstarlet sel -t -v "//root/date" MDrivenServerOnCo...")
     
    No edit summary
     
    (21 intermediate revisions by 4 users not shown)
    Line 1: Line 1:
    {{Edited|July|12|2025}}
    How to deploy the MDriven Server and Turnkey on your local machine using Docker.


    Create a docker file for the MDriven Server
    Start by installing [https://www.docker.com/products/docker-desktop/ Docker Desktop]. Docker Desktop is mainly for managing containers so installing it is optional. <syntaxhighlight>
    -------------------- Folder Structure ------------------


    Contents of ''<u>MDrivenServer.Dockerfile</u>''<syntaxhighlight lang="dockerfile">
    \---Apps
    # syntax=docker/dockerfile:1
        |  compose.yaml                    - [configuration file for starting the MDriven Turnkey and Server as services]
        |  MDrivenServer.Dockerfile       - [Docker file for creating MDriven Server container image]
        |  MDrivenTurnkey.Dockerfile      - [Docker file for creating MDriven Turnkey containere image]
        \---turnkey-settings
            |  HardServerUrl.xml          - [Setting for specifying the URL to be used by the Turnkey Server]
            |  MDrivenServerOverride.xml  - [Settings for the Turnkey to connect to the MDriven Server]
       
    </syntaxhighlight>
     
    === MDrivenServer Dockerfile ===
    '''i)''' Start with a base image of a Linux distribution


    '''ii)''' Install the .NET SDK. For this case, we will use a Microsoft base image that is packaged with the .NET SDK. Choose an image based on the .NET SDK version to use and Linux flavour from  https://github.com/dotnet/dotnet-docker/blob/main/README.sdk.md.<syntaxhighlight>
    FROM mcr.microsoft.com/dotnet/sdk:8.0-alpine
    FROM mcr.microsoft.com/dotnet/sdk:8.0-alpine
     
    </syntaxhighlight>'''iii)''' Copy the MDriven Server files to the image or download the latest MDriven Server and  extract it into the image.<syntaxhighlight>
    RUN apk add --upgrade --no-cache \
    RUN apk add --upgrade --no-cache \
             curl \
             curl \
    Line 22: Line 36:
         && unzip "MDrivenServerCoreLinux_${MS_VERSION}.zip" \
         && unzip "MDrivenServerCoreLinux_${MS_VERSION}.zip" \
         && rm -f "MDrivenServerCoreLinux_${MS_VERSION}.zip"
         && rm -f "MDrivenServerCoreLinux_${MS_VERSION}.zip"
    </syntaxhighlight>Install Curl, unzip and xmstarlet packages for downloading and extracting the latest version of the MDriven Server for Linux. It is important to clean up residue files from upgrading Linux packages and file downloads. This is to keep the image size from getting overly big.


    '''MDriven Server Current Version:''' https://mdriven.net/PublicDownloads/MDrivenServerOnCoreVersion.xml


    '''MDriven Server Download Source:''' <nowiki>https://mdriven.net/PublicDownloads/MDrivenServerCoreLinux_</nowiki><<MDriven Server Version>>.zip
    '''iv)''' Set the package source for [[Documentation:VistaDB|VistaDB]]<syntaxhighlight>
    RUN dotnet nuget add source /mnt/c/capableobjectswush/Xternal/VistaDB --name  XternatVistaDB
    RUN dotnet nuget add source /mnt/c/capableobjectswush/Xternal/VistaDB --name  XternatVistaDB
     
    </syntaxhighlight>'''v)''' Lastly start the MDriven Server<syntaxhighlight>
    ENTRYPOINT ["dotnet", "AppCompleteGenericCore.dll", "-port=5010", "-nohttps"]
    ENTRYPOINT ["dotnet", "AppCompleteGenericCore.dll", "-port=5010", "-nohttps"]
    </syntaxhighlight>
    </syntaxhighlight>
    {| class="wikitable"
    !Command
    !Description
    |-
    |<code>FROM mcr.microsoft.com/dotnet/sdk:</code><code>8.0-alpine</code>
    |Base image for the container MDriven Server app. An Alpine Linux distribution with .NET 8.0 SDK for running .NET applications.
    Check https://github.com/dotnet/dotnet-docker/blob/main/README.sdk.md for more .NET SDK container images.
    |-
    |<code>RUN apk add --upgrade --no-cache \</code><code>        curl \</code>
    <code>        unzip \</code>
    <code>        xmlstarlet</code>
    |Updates the existing linux packages and installs packages:  curl for downloading files, unzip for extracting zip file contents and xmlstarlet for parsing xml content.
    |-
    |<code>WORKDIR /app</code>
    |Sets the working dir for the following commands.
    |-
    |<code>ARG MS_VERSION</code>
    |Creates MS_VERSION build-time variable called MS_VERSION.
    |-
    |<code>RUN curl -O <nowiki>https://mdriven.net/PublicDownloads/MDrivenServerOnCoreVersion.xml</nowiki> \</code><code>    && MS_VERSION=$(xmlstarlet sel -t -v "//root/date" MDrivenServerOnCoreVersion.xml) \</code>
    <code>    && rm -f MDrivenServerOnCoreVersion.xml \</code>
    <code>    && curl -O "<nowiki>https://mdriven.net/PublicDownloads/MDrivenServerCoreLinux_${MS_VERSION}.zip</nowiki>" \</code>
    <code>    && unzip "MDrivenServerCoreLinux_${MS_VERSION}.zip" \</code>
    <code>    && rm -f "MDrivenServerCoreLinux_${MS_VERSION}.zip"</code>
    |Get the current MDriven Version, use it to download the current MDriven Server app and unzip it into the current working directory. If you have an existing MDriven Server instance, copy the files to the container.<syntaxhighlight>
    COPY ./mdriven-files .
    </syntaxhighlight>
    |-
    |<code>RUN dotnet nuget add source /mnt/c/capableobjectswush/Xternal/VistaDB --name  XternatVistaDB</code>
    |Add the VistaDB package source.
    |-
    |<code>ENTRYPOINT ["dotnet", "AppCompleteGenericCore.dll", "-port=5010", "-nohttps"]</code>
    |Run the application on port 5010 and over http.
    |}Create a docker file for the Turnkey Server


    contents of ''<u>MDrivenTurnkey.Dockerfile</u>''<syntaxhighlight lang="dockerfile">
    === MDriven Turnkey Dockerfile ===
    # syntax=docker/dockerfile:1
    '''i)''' Start with a base image of a Linux distribution


    '''ii)''' Install the .NET SDK. For this case, we will use a Microsoft base image that is packaged with the .NET SDK. Choose an image based on the .NET SDK version to use and Linux flavour from https://github.com/dotnet/dotnet-docker/blob/main/README.sdk.md.<syntaxhighlight>
    FROM mcr.microsoft.com/dotnet/sdk:8.0-alpine
    FROM mcr.microsoft.com/dotnet/sdk:8.0-alpine
     
    </syntaxhighlight>'''iii)''' Copy the MDriven Turnkey files to the image or download the latest MDriven Turnkey and  extract it into the container.<syntaxhighlight>
    RUN apk add --upgrade --no-cache \
    RUN apk add --upgrade --no-cache \
             curl \
             curl \
    Line 96: Line 76:
         && unzip "MDrivenTurnkeyCoreLinuxMUSL_${TK_VERSION}.zip" \
         && unzip "MDrivenTurnkeyCoreLinuxMUSL_${TK_VERSION}.zip" \
         && rm -f "MDrivenTurnkeyCoreLinuxMUSL_${TK_VERSION}.zip"
         && rm -f "MDrivenTurnkeyCoreLinuxMUSL_${TK_VERSION}.zip"
    </syntaxhighlight>Install Curl, unzip and xmstarlet packages for downloading and extract the latest version of the MDriven Server for Linux. Install locale settings if they are not available in the Linux image and set language. It is important to clean up residue files from upgrading Linux packages and file downloads. This is to prevent the image size from becoming overly big.


    '''Turnkey Current Version''': https://mdriven.net/PublicDownloads/MDrivenTurnkeyOnCoreVersion.xml


    COPY ./turnkey-settings ./App_Data
    '''Turnkey Download Source (Alpine)''': <nowiki>https://mdriven.net/PublicDownloads/MDrivenTurnkeyCoreLinuxMUSL_</nowiki><<Turnkey Version>>.zip
     


    ENTRYPOINT ["dotnet", "StreaminAppCoreWebApp.dll", "-port=5020", "-nohttps"]
    '''Turnkey Download Source (Ubuntu)''': <nowiki>https://mdriven.net/PublicDownloads/MDrivenTurnkeyCoreLinux_</nowiki><<Turnkey Version>>.zip
    </syntaxhighlight>
    '''NOTE:''' For Turnkey Server, install locale packages and set language to prevent locale errors. The Turnkey uses the OS locale settings to determine which locale file is used by the Turnkey.
    copy Turnkey settings to Turnkey ''APP_Data'' Folder. The turnkey-settings folder contains:


    HardServerUrl Settings: To specify the address to be used by the Turnkey Server.
    '''iv)''' Copy the Turnkey Settings into the App_Data folder.<syntaxhighlight>
     
    COPY ./turnkey-settings ./App_Data
    MDrivenServerOverride Settings: TO specify credentials for connecting to the MDriven Server
    </syntaxhighlight>Contents of ''turnkey-settings/HardServerUrl.xml''<syntaxhighlight lang="xml">
     
    contents of <u>turnkey-settings/HardServerUrl.xml</u><syntaxhighlight lang="xml">
    <?xml version="1.0" encoding="utf-8"?>
    <?xml version="1.0" encoding="utf-8"?>
    <root HardServerUrl="http://localhost:5020">
    <root HardServerUrl="http://localhost:5020">
    </root>
    </root>
    </syntaxhighlight>contents of <u>turnkey-settings/MDrivenServerOverride.xml</u><syntaxhighlight lang="xml">
    </syntaxhighlight>Contents of ''turnkey-settings/MDrivenServerOverride.xml''<syntaxhighlight lang="xml">
    <?xml version="1.0" encoding="utf-8"?>
    <?xml version="1.0" encoding="utf-8"?>
    <root>
    <root>
       <MDrivenServerOverride MDrivenServerPWD="123456" MDrivenServerUSER="a">http://mdriven-server:5010</MDrivenServerOverride>
       <MDrivenServerOverride MDrivenServerPWD="123456" MDrivenServerUSER="a">http://mdriven_server:5010</MDrivenServerOverride>
    </root>
    </root>
    </syntaxhighlight>contents of ''<u>compose.yaml</u>''<syntaxhighlight lang="yaml">
    </syntaxhighlight>'''v)''' Lastly, start the MDriven Turnkey.<syntaxhighlight>
    ENTRYPOINT ["dotnet", "StreaminAppCoreWebApp.dll", "-port=5020", "-nohttps"]
    </syntaxhighlight>
     
    === Compose File ===
    The Compose file is a single configuration file for building and starting the container images for the MDriven Server and MDriven Turnkey.<syntaxhighlight lang="yaml">


    services:
    services:
       mdriven-server:
       mdriven_server:
         build:
         build:
           dockerfile: MDrivenServer.Dockerfile
           dockerfile: MDrivenServer.Dockerfile
         networks:
         networks:
           - app-net
           - app_net
         volumes:
         volumes:
           - mdriven-server-data:/app
           - mdriven_server_data:/app
         ports:
         ports:
           - 5010:5010
           - 5010:5010
         healthcheck:
         healthcheck:
           test: ["CMD", "curl", "-f", "http://localhost:5010"]
           test: ["CMD", "curl", "-f", "http://localhost:5010"]
           interval: 24h
           interval: 1h
           timeout: 30s
           timeout: 30s
           retries: 5
           retries: 5
           start_period: 30s
           start_period: 30s


     
       mdriven_turnkey:
       mdriven-turnkey:
         build:
         build:
           dockerfile: MDrivenTurnkey.Dockerfile
           dockerfile: MDrivenTurnkey.Dockerfile
         networks:
         networks:
           - app-net
           - app_net
         volumes:
         volumes:
           - mdriven-turnkey-data:/app
           - mdriven_turnkey_data:/app
         ports:
         ports:
           - 5020:5020
           - 5011:5011
         depends_on:
         depends_on:
           - mdriven-server
           - mdriven_server
     


    volumes:
    volumes:
       mdriven-turnkey-data:
       mdriven_turnkey_data:
       mdriven-server-data:
       mdriven_server_data:
    networks:
    networks:
       app-net:
       app_net:




    </syntaxhighlight><code>mdriven-server:</code> creates a service for the MDriven Server using the MDrivenServer.Dockerfile file, the MDriven Server is connected to and available in the app-net network. The service is binding port 5010 on your host machine to 5010 port on which the MDriven Server is running in the container. The volume is added to persist the MDriven Server files in the /app folder whereit is currently located and running in the container. This allows for updating of the linux OS packages and images while leaving your Server data intact. without a volume, the server data is destroyed when container stops running.
    </syntaxhighlight><code>mdriven_server:</code> creates a service for the MDriven Server using the MDrivenServer.Dockerfile file. The MDriven Server is connected to and available in the app_net network. The service is binding port 5010 on your host machine to 5010 port on which the MDriven Server is running in the container. The volume is added to persist the MDriven Server files in the /app folder where it is currently located and running in the container. This allows for updating the Linux OS packages and images while leaving your Server data intact. Without a volume, the server data is destroyed when the container stops running.


    The <code>health check:</code> on the MDriven Server is to solve the issue of Vista DB locking itself, a check is performed every after 24 hours and server is restarted to clear the lock state.
    The <code>healthcheck:</code> on the MDriven Server is to solve the issue of Vista DB locking itself. A check is performed after every hour and the server is restarted to clear the lock state. The healthcheck interval can be reduced based on the expected availability of the server.


    <code>mdriven-turnkey:</code> creates a service for the MDriven Turnkey using the MDrivenTurnkey.Dockerfile file, the MDriven Turnkey is connected to and available in the app-net network. The service is binding port 5020 on your host machine to 5020 port on which the MDriven Turnkey is running in the container. The volume is added to persist the MDriven Turnkey files in the /app folder where it is currently located and running in the container.
    <code>mdriven_turnkey:</code> creates a service for the MDriven Turnkey using the MDrivenTurnkey.Dockerfile file. The MDriven Turnkey is connected to and available in the app-net network. The service is binding port 5020 on your host machine to 5020 port on which the MDriven Turnkey is running in the container. The volume is added to persist the MDriven Turnkey files in the /app folder where it is currently located and running in the container.


    Adding <code>depends_on:</code> ensures the Turnkey service only starts after the MDriven Server has started.
    Adding <code>depends_on:</code> ensures the Turnkey service only starts after the MDriven Server has started.


    <code>app-net:</code>  is a network shared by the two services so that they can be able to communicate to each other.
    <code>app_net:</code>  is a network shared by the two services so that they can communicate to each other.
    ====See also:====
     
    === How To Run Setup ===
    Within the /Apps folder, run<syntaxhighlight lang="shell">
    docker compose up -d
    </syntaxhighlight>
     
    ==== See also: ====
    *[[Documentation:WSL Windows subsystem for Linux|WSL Windows subsystem for Linux]]
    *[[Documentation:WSL Windows subsystem for Linux|WSL Windows subsystem for Linux]]

    Latest revision as of 03:16, 11 March 2025

    This page was created by Charles on 2024-11-11. Last edited by Charles@mdriven.net on 2025-03-11.

    How to deploy the MDriven Server and Turnkey on your local machine using Docker.

    Start by installing Docker Desktop. Docker Desktop is mainly for managing containers so installing it is optional. 

    -------------------- Folder Structure ------------------

\---Apps
    |   compose.yaml                    - [configuration file for starting the MDriven Turnkey and Server as services]
    |   MDrivenServer.Dockerfile        - [Docker file for creating MDriven Server container image]
    |   MDrivenTurnkey.Dockerfile       - [Docker file for creating MDriven Turnkey containere image]
    \---turnkey-settings
        |   HardServerUrl.xml           - [Setting for specifying the URL to be used by the Turnkey Server]
        |   MDrivenServerOverride.xml   - [Settings for the Turnkey to connect to the MDriven Server]

    MDrivenServer Dockerfile

    i) Start with a base image of a Linux distribution

    ii) Install the .NET SDK. For this case, we will use a Microsoft base image that is packaged with the .NET SDK. Choose an image based on the .NET SDK version to use and Linux flavour from https://github.com/dotnet/dotnet-docker/blob/main/README.sdk.md.

    FROM mcr.microsoft.com/dotnet/sdk:8.0-alpine

    iii) Copy the MDriven Server files to the image or download the latest MDriven Server and extract it into the image.

    RUN apk add --upgrade --no-cache \
        curl \
        unzip \
        xmlstarlet 

WORKDIR /app

ARG MS_VERSION

RUN curl -O https://mdriven.net/PublicDownloads/MDrivenServerOnCoreVersion.xml \
    && MS_VERSION=$(xmlstarlet sel -t -v "//root/date" MDrivenServerOnCoreVersion.xml) \
    && rm -f MDrivenServerOnCoreVersion.xml \
    && curl -O "https://mdriven.net/PublicDownloads/MDrivenServerCoreLinux_${MS_VERSION}.zip" \
    && unzip "MDrivenServerCoreLinux_${MS_VERSION}.zip" \
    && rm -f "MDrivenServerCoreLinux_${MS_VERSION}.zip"

    Install Curl, unzip and xmstarlet packages for downloading and extracting the latest version of the MDriven Server for Linux. It is important to clean up residue files from upgrading Linux packages and file downloads. This is to keep the image size from getting overly big.

    MDriven Server Current Version: https://mdriven.net/PublicDownloads/MDrivenServerOnCoreVersion.xml

    MDriven Server Download Source: https://mdriven.net/PublicDownloads/MDrivenServerCoreLinux_<<MDriven Server Version>>.zip

    iv) Set the package source for VistaDB

    RUN dotnet nuget add source /mnt/c/capableobjectswush/Xternal/VistaDB --name  XternatVistaDB

    v) Lastly start the MDriven Server

    ENTRYPOINT ["dotnet", "AppCompleteGenericCore.dll", "-port=5010", "-nohttps"]

    MDriven Turnkey Dockerfile

    i) Start with a base image of a Linux distribution

    ii) Install the .NET SDK. For this case, we will use a Microsoft base image that is packaged with the .NET SDK. Choose an image based on the .NET SDK version to use and Linux flavour from https://github.com/dotnet/dotnet-docker/blob/main/README.sdk.md.

    FROM mcr.microsoft.com/dotnet/sdk:8.0-alpine

    iii) Copy the MDriven Turnkey files to the image or download the latest MDriven Turnkey and extract it into the container.

    RUN apk add --upgrade --no-cache \
        curl \
        unzip \
        xmlstarlet \
        musl-locales

ENV LANG=en_US.UTF-8
ENV LANGUAGE=en_US:en
ENV LC_ALL=en_US.UTF-8

RUN locale -a

WORKDIR /app

ARG TK_VERSION

RUN curl -O https://mdriven.net/PublicDownloads/MDrivenTurnkeyOnCoreVersion.xml \
    && TK_VERSION=$(xmlstarlet sel -t -v "//root/date" MDrivenTurnkeyOnCoreVersion.xml) \
    && rm -f MDrivenTurnkeyOnCoreVersion.xml \
    && curl -O "https://mdriven.net/PublicDownloads/MDrivenTurnkeyCoreLinuxMUSL_${TK_VERSION}.zip" \
    && unzip "MDrivenTurnkeyCoreLinuxMUSL_${TK_VERSION}.zip" \
    && rm -f "MDrivenTurnkeyCoreLinuxMUSL_${TK_VERSION}.zip"

    Install Curl, unzip and xmstarlet packages for downloading and extract the latest version of the MDriven Server for Linux. Install locale settings if they are not available in the Linux image and set language. It is important to clean up residue files from upgrading Linux packages and file downloads. This is to prevent the image size from becoming overly big.

    Turnkey Current Version: https://mdriven.net/PublicDownloads/MDrivenTurnkeyOnCoreVersion.xml

    Turnkey Download Source (Alpine): https://mdriven.net/PublicDownloads/MDrivenTurnkeyCoreLinuxMUSL_<<Turnkey Version>>.zip

    Turnkey Download Source (Ubuntu): https://mdriven.net/PublicDownloads/MDrivenTurnkeyCoreLinux_<<Turnkey Version>>.zip

    iv) Copy the Turnkey Settings into the App_Data folder.

    COPY ./turnkey-settings ./App_Data

    Contents of turnkey-settings/HardServerUrl.xml

    <?xml version="1.0" encoding="utf-8"?>
<root HardServerUrl="http://localhost:5020">
</root>

    Contents of turnkey-settings/MDrivenServerOverride.xml

    <?xml version="1.0" encoding="utf-8"?>
<root>
  <MDrivenServerOverride MDrivenServerPWD="123456" MDrivenServerUSER="a">http://mdriven_server:5010</MDrivenServerOverride>
</root>

    v) Lastly, start the MDriven Turnkey.

    ENTRYPOINT ["dotnet", "StreaminAppCoreWebApp.dll", "-port=5020", "-nohttps"]

    Compose File

    The Compose file is a single configuration file for building and starting the container images for the MDriven Server and MDriven Turnkey.

    services:
  mdriven_server:
    build:
      dockerfile: MDrivenServer.Dockerfile
    networks:
      - app_net
    volumes:
      - mdriven_server_data:/app
    ports:
      - 5010:5010
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:5010"]
      interval: 1h
      timeout: 30s
      retries: 5
      start_period: 30s

  mdriven_turnkey:
    build:
      dockerfile: MDrivenTurnkey.Dockerfile
    networks:
      - app_net
    volumes:
      - mdriven_turnkey_data:/app
    ports:
      - 5011:5011
    depends_on:
      - mdriven_server

volumes:
  mdriven_turnkey_data:
  mdriven_server_data:
networks:
  app_net:

    mdriven_server: creates a service for the MDriven Server using the MDrivenServer.Dockerfile file. The MDriven Server is connected to and available in the app_net network. The service is binding port 5010 on your host machine to 5010 port on which the MDriven Server is running in the container. The volume is added to persist the MDriven Server files in the /app folder where it is currently located and running in the container. This allows for updating the Linux OS packages and images while leaving your Server data intact. Without a volume, the server data is destroyed when the container stops running.

    The healthcheck: on the MDriven Server is to solve the issue of Vista DB locking itself. A check is performed after every hour and the server is restarted to clear the lock state. The healthcheck interval can be reduced based on the expected availability of the server.

    mdriven_turnkey: creates a service for the MDriven Turnkey using the MDrivenTurnkey.Dockerfile file. The MDriven Turnkey is connected to and available in the app-net network. The service is binding port 5020 on your host machine to 5020 port on which the MDriven Turnkey is running in the container. The volume is added to persist the MDriven Turnkey files in the /app folder where it is currently located and running in the container.

    Adding depends_on: ensures the Turnkey service only starts after the MDriven Server has started.

    app_net: is a network shared by the two services so that they can communicate to each other.

    How To Run Setup

    Within the /Apps folder, run

    docker compose up -d

    See also:

    Retrieved from "https://wiki.mdriven.net/index.php?title=Documentation:Docker_Local_Deployment&oldid=26731"

    © MDRIVEN . All Rights Reserved

    API Docs
    MDriven World | Portal | Blog | YouTube | StackOverflow | Facebook

    © MDRIVEN . All Rights Reserved