Pin Docker image eclipse-temurin:17-jre-focal

eclipse-temurin:17-jre-focal -> eclipse-temurin:17-jre-focal@sha256:55c1ff40a91898c456dc5a874a66db17b6aa1b4aef8d9cac1ad3b194575638a1 [atomist:generated] [atomist-skill:atomist/docker-base-image-policy] Signed-off-by: Atomist Bot <bot@atomist.com>
Pin Docker image maven:3.8.5-eclipse-temurin-17
2022-10-07 01:36:45 +00:00 · 2022-10-07 01:36:45 +00:00
32 changed files with 7 additions and 1798 deletions
--- a/README.md
+++ b/README.md
@ -20,8 +20,6 @@ These samples provide a starting point for how to integrate different services u
 <a href="https://docs.docker.com/desktop/dev-environments/"><img src="icon_devenvs.svg" alt="Use with Docker Dev Environments" height="30" align="top"/></a> Icon indicates Sample is compatible with [Docker Dev Environments](https://docs.docker.com/desktop/dev-environments/) in Docker Desktop version 4.10 or later.
 <a href="https://docs.docker.com/desktop/wasm/"><img src="icon_wasm.svg" alt="Docker + wasm" height="30" align="top"/></a> Icon indicates Sample is compatible with [Docker+Wasm](https://docs.docker.com/desktop/wasm/).
 - [`ASP.NET / MS-SQL`](aspnet-mssql) - Sample ASP.NET core application
 with MS SQL server database.
 - [`Elasticsearch / Logstash / Kibana`](elasticsearch-logstash-kibana) - Sample Elasticsearch, Logstash, and Kibana stack.
@ -51,8 +49,6 @@ application with a Rust backend and a Postgres database.&nbsp;<a href="react-rus
 - [`React / Nginx`](react-nginx) - Sample React application with Nginx.&nbsp;<a href="react-nginx"><img src="icon_devenvs.svg" alt="Use with Docker Dev Environments" height="30" align="top"/></a>
 - [`Spring / PostgreSQL`](spring-postgres) - Sample Java application
 with Spring framework and a Postgres database.&nbsp;<a href="spring-postgres"><img src="icon_devenvs.svg" alt="Use with Docker Dev Environments" height="30" align="top"/></a>
 - [`WasmEdge / MySQL / Nginx`](wasmedge-mysql-nginx) - Sample Wasm-based web application with a static HTML frontend, using a MySQL (MariaDB) database. The frontend connects to a Wasm microservice written in Rust, that runs using the WasmEdge runtime.&nbsp;<a href="wasmedge-mysql-nginx"><img src="icon_wasm.svg" alt="Compatible with Docker+wasm" height="30" align="top"/></a>
 - [`WasmEdge / Kafka / MySQL`](wasmedge-kafka-mysql) - Sample Wasm-based microservice that subscribes to a Kafka (Redpanda) queue topic, and transforms and saves any incoming message into a MySQL (MariaDB) database.&nbsp;<a href="wasmedge-kafka-mysql"><img src="icon_wasm.svg" alt="Compatible with Docker+wasm" height="30" align="top"/></a>
 ## Single service samples
@ -113,11 +109,6 @@ To stop and remove all containers of the sample application run:
 ```console
 docker compose down
 ```
 ### Quickstart guides
 In addition to all the ready to run Compose samples listed above the folder [official-documentation-samples](official-documentation-samples/README.md) contains quickstart guides. Each of these step by step guides explain which files need to be created to build and run a Docker Compose application.
 <!--lint disable awesome-toc-->
 ## Contribute
--- a/fastapi/compose.yaml
+++ b/fastapi/compose.yaml
@ -7,5 +7,5 @@ services:
    environment:
      PORT: 8000
    ports:
-      - '8010:8000'
+      - '8000:8000'
    restart: "no"
--- a/icon_wasm.svg
+++ b/icon_wasm.svg
@ -1,13 +0,0 @@
 <svg id="WA-icon" xmlns="http://www.w3.org/2000/svg" width="144" height="111" viewBox="0 0 1440 1110">
  <defs>
    <style>
      .cls-1 {
        fill: #6f45f9;
        fill-rule: evenodd;
      }
    </style>
  </defs>
  <path id="shape_4" data-name="shape 4" class="cls-1" d="M445,280H651v7s0.437,32.383,29,49c30.515,17.752,62.137,4.583,72-4,10.362-9.017,22.2-23.3,23-45v-7H981V816H445V280ZM569,567h36l24,128,30-128h33l27,128,28-127h35L737,759H702L675,631,646,759H610ZM776,759l46-191h57l55,191H897l-12-42H820l-9,42H776Z" transform="translate(0.594 9.312)"/>
  <path id="shape_1" data-name="shape 1" class="cls-1" d="M827,685.471l16-71h15l19,71H827Z" transform="translate(0.594 9.312)"/>
  <path id="shape_3" data-name="shape 3" class="cls-1" d="M323,232.471l-122,54s-32,12.311-32,51v412s-4.458,38.615,29,54,497,221,497,221,22.409,11.15,46,1,116-51,116-51,14.081-5.669,14-22c-0.088-17.6-16.3-33.023-36-24s-96,43-96,43-17.573,10.1-37,2-449-198-449-198-24-11.257-24-40v-374a42.353,42.353,0,0,1,25-38c25.972-12.225,88-39,88-39s18-5.765,18-26C360,237.118,338.709,225.966,323,232.471Zm284-127,93-41s19.94-8.9,51,5,485,216,485,216,34,14.168,34,51v422s0.85,30.084-26,43-116,53-116,53-14.98,4.522-25-7-8.79-32.833,5-39,67-29,67-29l8-4s23-12.024,23-46v-369s1.61-26.142-28-39-437-194-437-194-21.48-9.931-40-2-77,34-77,34-22.162,7.988-33-8S584.324,115.515,607,105.471Z" transform="translate(0.594 9.312)"/>
 </svg>
--- a/official-documentation-samples/README.md
+++ b/official-documentation-samples/README.md
@ -1,28 +0,0 @@
 # Sample apps with Compose
 The following samples show the various aspects of how to work with Docker
 Compose. As a prerequisite, be sure to [install Docker Compose](https://docs.docker.com/compose/install/)
 if you have not already done so.
 ## Key concepts these samples cover
 The samples should help you to:
 - define services based on Docker images using
  [Compose files](https://docs.docker.com/compose/compose-file/) `docker-compose.yml` files
 - understand the relationship between `docker-compose.yml` and
  [Dockerfiles](https://docs.docker.com/engine/reference/builder/)
 - learn how to make calls to your application services from Compose files
 ## Samples tailored to demo Compose
 These samples focus specifically on Docker Compose:
 - [Quickstart: Compose and Django](./django/README.md) - Shows how to use Docker Compose to set up and run a simple Django/PostgreSQL app.
 - [Quickstart: Compose and Rails](./rails/README.md) - Shows how to use
 Docker Compose to set up and run a Rails/PostgreSQL app.
 - [Quickstart: Compose and WordPress](./wordpress/README.md) - Shows how to
 use Docker Compose to set up and run WordPress in an isolated environment
 with Docker containers.
--- a/official-documentation-samples/django/README.md
+++ b/official-documentation-samples/django/README.md
@ -1,286 +0,0 @@
 # Quickstart: Compose and Django
 This quick-start guide demonstrates how to use Docker Compose to set up and run a simple Django/PostgreSQL app. Before starting,
 [install Compose](https://docs.docker.com/compose/install/).
 ## Define the project components
 For this project, you need to create a Dockerfile, a Python dependencies file,
 and a `docker-compose.yml` file. (You can use either a `.yml` or `.yaml` extension for this file.)
 1. Create an empty project directory.
    You can name the directory something easy for you to remember. This directory is the context for your application image. The directory should only contain resources to build that image.
 2. Create a new file called `Dockerfile` in your project directory.
    The Dockerfile defines an application's image content via one or more build
    commands that configure that image. Once built, you can run the image in a
    container.  For more information on `Dockerfile`, see the [Docker user guide](https://docs.docker.com/get-started/)
    and the [Dockerfile reference](https://docs.docker.com/engine/reference/builder/).
 3. Add the following content to the `Dockerfile`.
   ```dockerfile
   # syntax=docker/dockerfile:1
   FROM python:3
   ENV PYTHONDONTWRITEBYTECODE=1
   ENV PYTHONUNBUFFERED=1
   WORKDIR /code
   COPY requirements.txt /code/
   RUN pip install -r requirements.txt
   COPY . /code/
   ```
   This `Dockerfile` starts with a [Python 3 parent image](https://hub.docker.com/r/library/python/tags/3/).
   The parent image is modified by adding a new `code` directory. The parent image is further modified
   by installing the Python requirements defined in the `requirements.txt` file.
 4. Save and close the `Dockerfile`.
 5. Create a `requirements.txt` in your project directory.
    This file is used by the `RUN pip install -r requirements.txt` command in your `Dockerfile`.
 6. Add the required software in the file.
    ```python
    Django>=3.0,<4.0
    psycopg2>=2.8
    ```
 7. Save and close the `requirements.txt` file.
 8. Create a file called `docker-compose.yml` in your project directory.
    The `docker-compose.yml` file describes the services that make your app. In
    this example those services are a web server and database.  The compose file
    also describes which Docker images these services use, how they link
    together, any volumes they might need to be mounted inside the containers.
    Finally, the `docker-compose.yml` file describes which ports these services
    expose. See the [`docker-compose.yml` reference](https://docs.docker.com/compose/compose-file/) for more
    information on how this file works.
 9. Add the following configuration to the file.
   ```yaml
   services:
     db:
       image: postgres
       volumes:
         - ./data/db:/var/lib/postgresql/data
       environment:
         - POSTGRES_DB=postgres
         - POSTGRES_USER=postgres
         - POSTGRES_PASSWORD=postgres
     web:
       build: .
       command: python manage.py runserver 0.0.0.0:8000
       volumes:
         - .:/code
       ports:
         - "8000:8000"
       environment:
         - POSTGRES_NAME=postgres
         - POSTGRES_USER=postgres
         - POSTGRES_PASSWORD=postgres
       depends_on:
         - db
   ```
   This file defines two services: The `db` service and the `web` service.
   > Note:
   >
   > This uses the build in development server to run your application
   > on port 8000. Do not use this in a production environment. For more
   > information, see [Django documentation](https://docs.djangoproject.com/en/3.1/intro/tutorial01/#the-development-server){: target="_blank" rel="noopener" class="_”}.
 10. Save and close the `docker-compose.yml` file.
 ## Create a Django project
 In this step, you create a Django starter project by building the image from the build context defined in the previous procedure.
 1. Change to the root of your project directory.
 2. Create the Django project by running the [docker compose run](https://docs.docker.com/engine/reference/commandline/compose_run/)
   command as follows.
   ```console
   sudo docker compose run web django-admin startproject composeexample .
   ```
   This instructs Compose to run `django-admin startproject composeexample`
   in a container, using the `web` service's image and configuration. Because
   the `web` image doesn't exist yet, Compose builds it from the current
   directory, as specified by the `build: .` line in `docker-compose.yml`.
   Once the `web` service image is built, Compose runs it and executes the
   `django-admin startproject` command in the container. This command
   instructs Django to create a set of files and directories representing a
   Django project.
 3. After the `docker compose` command completes, list the contents of your project.
   ```console
   $ ls -l
   drwxr-xr-x 2 root   root   composeexample
   drwxr-xr-x 3 root   root   data
   -rw-rw-r-- 1 user   user   docker-compose.yml
   -rw-rw-r-- 1 user   user   Dockerfile
   -rwxr-xr-x 1 root   root   manage.py
   -rw-rw-r-- 1 user   user   requirements.txt
   ```
   If you are running Docker on Linux, the files `django-admin` created are
   owned by root. This happens because the container runs as the root user.
   Change the ownership of the new files.
   Do not change the permission of the data folder where Postgres has its file, otherwise Postgres will not be able to start due to permission issues.
   ```console
   sudo chown -R $USER:$USER composeexample manage.py
   ```
   If you are running Docker on Mac or Windows, you should already
   have ownership of all files, including those generated by
   `django-admin`. List the files just to verify this.
   ```console
   $ ls -l
   total 32
   -rw-r--r--  1 user  staff  145 Feb 13 23:00 Dockerfile
   drwxr-xr-x  6 user  staff  204 Feb 13 23:07 composeexample
   -rw-r--r--  1 user  staff  159 Feb 13 23:02 docker-compose.yml
   -rwxr-xr-x  1 user  staff  257 Feb 13 23:07 manage.py
   -rw-r--r--  1 user  staff   16 Feb 13 23:01 requirements.txt
   ```
 ### Connect the database
 In this section, you set up the database connection for Django.
 1. In your project directory, edit the `composeexample/settings.py` file.
 2. Replace the `DATABASES = ...` with the following:
   ```python
   # settings.py
   import os
   [...]
   DATABASES = {
       'default': {
           'ENGINE': 'django.db.backends.postgresql',
           'NAME': os.environ.get('POSTGRES_NAME'),
           'USER': os.environ.get('POSTGRES_USER'),
           'PASSWORD': os.environ.get('POSTGRES_PASSWORD'),
           'HOST': 'db',
           'PORT': 5432,
       }
   }
   ```
   These settings are determined by the
   [postgres](https://hub.docker.com/_/postgres) Docker image
   specified in `docker-compose.yml`.
 3. Save and close the file.
 4. Run the [docker compose up](https://docs.docker.com/engine/reference/commandline/compose_up/) command from the top level directory for your project.
   ```console
   $ docker compose up
   djangosample_db_1 is up-to-date
   Creating djangosample_web_1 ...
   Creating djangosample_web_1 ... done
   Attaching to djangosample_db_1, djangosample_web_1
   db_1   | The files belonging to this database system will be owned by user "postgres".
   db_1   | This user must also own the server process.
   db_1   |
   db_1   | The database cluster will be initialized with locale "en_US.utf8".
   db_1   | The default database encoding has accordingly been set to "UTF8".
   db_1   | The default text search configuration will be set to "english".
   <...>
   web_1  | July 30, 2020 - 18:35:38
   web_1  | Django version 3.0.8, using settings 'composeexample.settings'
   web_1  | Starting development server at http://0.0.0.0:8000/
   web_1  | Quit the server with CONTROL-C.
   ```
   At this point, your Django app should be running at port `8000` on
   your Docker host. On Docker Desktop for Mac and Docker Desktop for Windows, go
   to `http://localhost:8000` on a web browser to see the Django
   welcome page.
   ![Django example](images/django-it-worked.png)
   > Note:
   >
   > On certain platforms (Windows 10), you might need to edit `ALLOWED_HOSTS`
   > inside `settings.py` and add your Docker host name or IP address to the list.
   > For demo purposes, you can set the value to:
   >
   > ```python
   > ALLOWED_HOSTS = ['*']
   > ```
   >
   > This value is **not** safe for production usage.  Refer to the
   > [Django documentation](https://docs.djangoproject.com/en/1.11/ref/settings/#allowed-hosts)  for more information.
 5. List running containers.
   In another terminal window, list the running Docker processes with the `docker ps` or `docker container ls` command.
   ```console
   $ docker ps
   CONTAINER ID  IMAGE       COMMAND                  CREATED         STATUS        PORTS                    NAMES
   def85eff5f51  django_web  "python3 manage.py..."   10 minutes ago  Up 9 minutes  0.0.0.0:8000->8000/tcp   django_web_1
   678ce61c79cc  postgres    "docker-entrypoint..."   20 minutes ago  Up 9 minutes  5432/tcp                 django_db_1
   ```
 6. Shut down services and clean up by using either of these methods:
    * Stop the application by typing `Ctrl-C`  in the same shell in where you
      started it:
      ```console
      Gracefully stopping... (press Ctrl+C again to force)
      Killing test_web_1 ... done
      Killing test_db_1 ... done
      ```
    * Or, for a more elegant shutdown, switch to a different shell, and run
      [docker compose down](https://docs.docker.com/engine/reference/commandline/compose_down/) from the top level of your
      Django sample project directory.
      ```console
      $ docker compose down
      Stopping django_web_1 ... done
      Stopping django_db_1 ... done
      Removing django_web_1 ... done
      Removing django_web_run_1 ... done
      Removing django_db_1 ... done
      Removing network django_default
      ```
  Once you've shut down the app, you can safely remove the Django project directory (for example, `rm -rf django`).
 ## More Compose documentation
 * [Docker Compose overview](https://docs.docker.com/compose/)
 * [Install Docker Compose](https://docs.docker.com/compose/install/)
 * [Getting Started with Docker Compose](https://docs.docker.com/compose/gettingstarted/)
 * [Docker Compose Command line reference](https://docs.docker.com/compose/reference/)
 * [Compose file reference](https://docs.docker.com/compose/compose-file/)
 * [Awesome Compose Django sample application](../../django/README.md)
--- a/official-documentation-samples/django/images/django-it-worked.png
+++ b/official-documentation-samples/django/images/django-it-worked.png
--- a/official-documentation-samples/rails/README.md
+++ b/official-documentation-samples/rails/README.md
@ -1,272 +0,0 @@
 # Quickstart: Compose and Rails
 This Quickstart guide shows you how to use Docker Compose to set up and run
 a Rails/PostgreSQL app. Before starting, [install Compose](https://docs.docker.com/compose/install/).
 ## Define the project
 Start by setting up the files needed to build the app. The app will run inside a
 Docker container containing its dependencies. Defining dependencies is done using
 a file called `Dockerfile`. To begin with, the  Dockerfile consists of:
 ```dockerfile
 # syntax=docker/dockerfile:1
 FROM ruby:2.5
 RUN apt-get update -qq && apt-get install -y nodejs postgresql-client
 WORKDIR /myapp
 COPY Gemfile /myapp/Gemfile
 COPY Gemfile.lock /myapp/Gemfile.lock
 RUN bundle install
 # Add a script to be executed every time the container starts.
 COPY entrypoint.sh /usr/bin/
 RUN chmod +x /usr/bin/entrypoint.sh
 ENTRYPOINT ["entrypoint.sh"]
 EXPOSE 3000
 # Configure the main process to run when running the image
 CMD ["rails", "server", "-b", "0.0.0.0"]
 ```
 That'll put your application code inside an image that builds a container
 with Ruby, Bundler and all your dependencies inside it. For more information on
 how to write Dockerfiles, see the [Docker user guide](https://docs.docker.com/get-started/)
 and the [Dockerfile reference](https://docs.docker.com/engine/reference/builder/).
 Next, open an editor and create a bootstrap `Gemfile` which just loads Rails. This will be overwritten in a moment by `rails new`.
 ```ruby
 source 'https://rubygems.org'
 gem 'rails', '~>5'
 ```
 Create an empty `Gemfile.lock` file to build our `Dockerfile`.
 ```console
 $ touch Gemfile.lock
 ```
 Next, provide an entrypoint script to fix a Rails-specific issue that
 prevents the server from restarting when a certain `server.pid` file pre-exists.
 This script will be executed every time the container gets started.
 `entrypoint.sh` consists of:
 ```bash
 #!/bin/bash
 set -e
 # Remove a potentially pre-existing server.pid for Rails.
 rm -f /myapp/tmp/pids/server.pid
 # Then exec the container's main process (what's set as CMD in the Dockerfile).
 exec "$@"
 ```
 Finally, `docker-compose.yml` is where the magic happens. This file describes
 the services that comprise your app (a database and a web app), how to get each
 one's Docker image (the database just runs on a pre-made PostgreSQL image, and
 the web app is built from the current directory), and the configuration needed
 to link them together and expose the web app's port.
 ```yaml
 services:
  db:
    image: postgres
    volumes:
      - ./tmp/db:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: password
  web:
    build: .
    command: bash -c "rm -f tmp/pids/server.pid && bundle exec rails s -p 3000 -b '0.0.0.0'"
    volumes:
      - .:/myapp
    ports:
      - "3000:3000"
    depends_on:
      - db
 ```
 > **Tip**
 >
 > You can use either a `.yml` or `.yaml` extension for this file.
 ### Build the project
 With those files in place, you can now generate the Rails skeleton app
 using [docker compose run](https://docs.docker.com/engine/reference/commandline/compose_run/):
 ```console
 $ docker compose run --no-deps web rails new . --force --database=postgresql
 ```
 First, Compose builds the image for the `web` service using the `Dockerfile`.
 The `--no-deps` tells Compose not to start linked services. Then it runs
 `rails new` inside a new container, using that image. Once it's done, you
 should have generated a fresh app.
 List the files.
 ```console
 $ ls -l
 total 64
 -rw-r--r--   1 vmb  staff   222 Jun  7 12:05 Dockerfile
 -rw-r--r--   1 vmb  staff  1738 Jun  7 12:09 Gemfile
 -rw-r--r--   1 vmb  staff  4297 Jun  7 12:09 Gemfile.lock
 -rw-r--r--   1 vmb  staff   374 Jun  7 12:09 README.md
 -rw-r--r--   1 vmb  staff   227 Jun  7 12:09 Rakefile
 drwxr-xr-x  10 vmb  staff   340 Jun  7 12:09 app
 drwxr-xr-x   8 vmb  staff   272 Jun  7 12:09 bin
 drwxr-xr-x  14 vmb  staff   476 Jun  7 12:09 config
 -rw-r--r--   1 vmb  staff   130 Jun  7 12:09 config.ru
 drwxr-xr-x   3 vmb  staff   102 Jun  7 12:09 db
 -rw-r--r--   1 vmb  staff   211 Jun  7 12:06 docker-compose.yml
 -rw-r--r--   1 vmb  staff   184 Jun  7 12:08 entrypoint.sh
 drwxr-xr-x   4 vmb  staff   136 Jun  7 12:09 lib
 drwxr-xr-x   3 vmb  staff   102 Jun  7 12:09 log
 -rw-r--r--   1 vmb  staff    63 Jun  7 12:09 package.json
 drwxr-xr-x   9 vmb  staff   306 Jun  7 12:09 public
 drwxr-xr-x   9 vmb  staff   306 Jun  7 12:09 test
 drwxr-xr-x   4 vmb  staff   136 Jun  7 12:09 tmp
 drwxr-xr-x   3 vmb  staff   102 Jun  7 12:09 vendor
 ```
 If you are running Docker on Linux, the files `rails new` created are owned by
 root. This happens because the container runs as the root user. If this is the
 case, change the ownership of the new files.
 ```console
 $ sudo chown -R $USER:$USER .
 ```
 If you are running Docker on Mac or Windows, you should already have ownership
 of all files, including those generated by `rails new`.
 Now that you’ve got a new Gemfile, you need to build the image again. (This, and
 changes to the `Gemfile` or the Dockerfile, should be the only times you’ll need
 to rebuild.)
 ```console
 $ docker compose build
 ```
 ### Connect the database
 The app is now bootable, but you're not quite there yet. By default, Rails
 expects a database to be running on `localhost` - so you need to point it at the
 `db` container instead. You also need to change the database and username to
 align with the defaults set by the `postgres` image.
 Replace the contents of `config/database.yml` with the following:
 ```yaml
 default: &default
  adapter: postgresql
  encoding: unicode
  host: db
  username: postgres
  password: password
  pool: 5
 development:
  <<: *default
  database: myapp_development
 test:
  <<: *default
  database: myapp_test
 ```
 You can now boot the app with [docker compose up](https://docs.docker.com/engine/reference/commandline/compose_up/).
 If all is well, you should see some PostgreSQL output:
 ```console
 $ docker compose up
 rails_db_1 is up-to-date
 Creating rails_web_1 ... done
 Attaching to rails_db_1, rails_web_1
 db_1   | PostgreSQL init process complete; ready for start up.
 db_1   |
 db_1   | 2018-03-21 20:18:37.437 UTC [1] LOG:  listening on IPv4 address "0.0.0.0", port 5432
 db_1   | 2018-03-21 20:18:37.437 UTC [1] LOG:  listening on IPv6 address "::", port 5432
 db_1   | 2018-03-21 20:18:37.443 UTC [1] LOG:  listening on Unix socket "/var/run/postgresql/.s.PGSQL.5432"
 db_1   | 2018-03-21 20:18:37.726 UTC [55] LOG:  database system was shut down at 2018-03-21 20:18:37 UTC
 db_1   | 2018-03-21 20:18:37.772 UTC [1] LOG:  database system is ready to accept connections
 ```
 Finally, you need to create the database. In another terminal, run:
 ```console
 $ docker compose run web rake db:create
 Starting rails_db_1 ... done
 Created database 'myapp_development'
 Created database 'myapp_test'
 ```
 ### View the Rails welcome page!
 That's it. Your app should now be running on port 3000 on your Docker daemon.
 On Docker Desktop for Mac and Docker Desktop for Windows, go to `http://localhost:3000` on a web
 browser to see the Rails Welcome.
 ![Rails example](images/rails-welcome.png)
 ### Stop the application
 To stop the application, run [docker compose down](https://docs.docker.com/engine/reference/commandline/compose_down/) in
 your project directory. You can use the same terminal window in which you
 started the database, or another one where you have access to a command prompt.
 This is a clean way to stop the application.
 ```console
 $ docker compose down
 Stopping rails_web_1 ... done
 Stopping rails_db_1 ... done
 Removing rails_web_run_1 ... done
 Removing rails_web_1 ... done
 Removing rails_db_1 ... done
 Removing network rails_default
 ```
 ### Restart the application
 To restart the application run `docker compose up` in the project directory.
 ### Rebuild the application
 If you make changes to the Gemfile or the Compose file to try out some different
 configurations, you need to rebuild. Some changes require only
 `docker compose up --build`, but a full rebuild requires a re-run of
 `docker compose run web bundle install` to sync changes in the `Gemfile.lock` to
 the host, followed by `docker compose up --build`.
 Here is an example of the first case, where a full rebuild is not necessary.
 Suppose you simply want to change the exposed port on the local host from `3000`
 in our first example to `3001`. Make the change to the Compose file to expose
 port `3000` on the container through a new port, `3001`, on the host, and save
 the changes:
 ```yaml
 ports:
  - "3001:3000"
 ```
 Now, rebuild and restart the app with `docker compose up --build`.
 Inside the container, your app is running on the same port as before `3000`, but
 the Rails Welcome is now available on `http://localhost:3001` on your local
 host.
 ## More Compose documentation
 * [Docker Compose overview](https://docs.docker.com/compose/)
 * [Install Docker Compose](https://docs.docker.com/compose/install/)
 * [Getting Started with Docker Compose](https://docs.docker.com/compose/gettingstarted/)
 * [Docker Compose Command line reference](https://docs.docker.com/compose/reference/)
 * [Compose file reference](https://docs.docker.com/compose/compose-file/)
--- a/official-documentation-samples/rails/images/rails-welcome.png
+++ b/official-documentation-samples/rails/images/rails-welcome.png
--- a/official-documentation-samples/wordpress/README.md
+++ b/official-documentation-samples/wordpress/README.md
@ -1,147 +0,0 @@
 # Quickstart: Compose and WordPress
 You can use Docker Compose to easily run WordPress in an isolated environment
 built with Docker containers. This quick-start guide demonstrates how to use
 Compose to set up and run WordPress. Before starting, make sure you have
 [Compose installed](https://docs.docker.com/compose/install/).
 ## Define the project
 1.  Create an empty project directory.
    You can name the directory something easy for you to remember.
    This directory is the context for your application image. The
    directory should only contain resources to build that image.
    This project directory contains a `docker-compose.yml` file which
    is complete in itself for a good starter wordpress project.
    >**Tip**: You can use either a `.yml` or `.yaml` extension for
    this file. They both work.
 2.  Change into your project directory.
    For example, if you named your directory `my_wordpress`:
    ```console
    $ cd my_wordpress/
    ```
 3.  Create a `docker-compose.yml` file that starts your
    `WordPress` blog and a separate `MySQL` instance with volume
    mounts for data persistence:
    ```yaml
    services:
      db:
        # We use a mariadb image which supports both amd64 & arm64 architecture
        image: mariadb:10.6.4-focal
        # If you really want to use MySQL, uncomment the following line
        #image: mysql:8.0.27
        command: '--default-authentication-plugin=mysql_native_password'
        volumes:
          - db_data:/var/lib/mysql
        restart: always
        environment:
          - MYSQL_ROOT_PASSWORD=somewordpress
          - MYSQL_DATABASE=wordpress
          - MYSQL_USER=wordpress
          - MYSQL_PASSWORD=wordpress
        expose:
          - 3306
          - 33060
      wordpress:
        image: wordpress:latest
        volumes:
          - wp_data:/var/www/html
        ports:
          - 80:80
        restart: always
        environment:
          - WORDPRESS_DB_HOST=db
          - WORDPRESS_DB_USER=wordpress
          - WORDPRESS_DB_PASSWORD=wordpress
          - WORDPRESS_DB_NAME=wordpress
    volumes:
      db_data:
      wp_data:
    ```
   > **Notes**:
   >
   * The docker volumes `db_data` and `wordpress_data` persists updates made by WordPress
   to the database, as well as the installed themes and plugins. [Learn more about docker volumes](https://docs.docker.com/storage/volumes/)
   >
   * WordPress Multisite works only on ports `80` and `443`.
   {: .note-vanilla}
 ### Build the project
 Now, run `docker compose up -d` from your project directory.
 This runs [`docker compose up`](https://docs.docker.com/engine/reference/commandline/compose_up/) in detached mode, pulls
 the needed Docker images, and starts the wordpress and database containers, as shown in
 the example below.
 ```console
 $ docker compose up -d
 Creating network "my_wordpress_default" with the default driver
 Pulling db (mysql:5.7)...
 5.7: Pulling from library/mysql
 efd26ecc9548: Pull complete
 a3ed95caeb02: Pull complete
 <...>
 Digest: sha256:34a0aca88e85f2efa5edff1cea77cf5d3147ad93545dbec99cfe705b03c520de
 Status: Downloaded newer image for mysql:5.7
 Pulling wordpress (wordpress:latest)...
 latest: Pulling from library/wordpress
 efd26ecc9548: Already exists
 a3ed95caeb02: Pull complete
 589a9d9a7c64: Pull complete
 <...>
 Digest: sha256:ed28506ae44d5def89075fd5c01456610cd6c64006addfe5210b8c675881aff6
 Status: Downloaded newer image for wordpress:latest
 Creating my_wordpress_db_1
 Creating my_wordpress_wordpress_1
 ```
 > **Note**: WordPress Multisite works only on ports `80` and/or `443`.
 If you get an error message about binding `0.0.0.0` to port `80` or `443`
 (depending on which one you specified), it is likely that the port you
 configured for WordPress is already in use by another service.
 ### Bring up WordPress in a web browser
 At this point, WordPress should be running on port `80` of your Docker Host,
 and you can complete the "famous five-minute installation" as a WordPress
 administrator.
 > **Note**: The WordPress site is not immediately available on port `80`
 because the containers are still being initialized and may take a couple of
 minutes before the first load.
 If you are using Docker Desktop for Mac or Docker Desktop for Windows, you can use
 `http://localhost` as the IP address, and open `http://localhost:80` in a web
 browser.
 ![Choose language for WordPress install](images/wordpress-lang.png)
 ![WordPress Welcome](images/wordpress-welcome.png)
 ### Shutdown and cleanup
 The command [`docker compose down`](https://docs.docker.com/engine/reference/commandline/compose_down/) removes the
 containers and default network, but preserves your WordPress database.
 The command `docker compose down --volumes` removes the containers, default
 network, and the WordPress database.
 ## More Compose documentation
 * [Docker Compose overview](https://docs.docker.com/compose/)
 * [Install Docker Compose](https://docs.docker.com/compose/install/)
 * [Getting Started with Docker Compose](https://docs.docker.com/compose/gettingstarted/)
 * [Docker Compose Command line reference](https://docs.docker.com/compose/reference/)
 * [Compose file reference](https://docs.docker.com/compose/compose-file/)
 * [Awesome Compose WordPress sample](../../wordpress-mysql/README.md)
--- a/official-documentation-samples/wordpress/images/wordpress-lang.png
+++ b/official-documentation-samples/wordpress/images/wordpress-lang.png
--- a/official-documentation-samples/wordpress/images/wordpress-welcome.png
+++ b/official-documentation-samples/wordpress/images/wordpress-welcome.png
--- a/react-express-mongodb/.docker/docker-compose.yaml
+++ b/react-express-mongodb/.docker/docker-compose.yaml
@ -29,6 +29,7 @@ services:
    expose: 
      - 3000
  mongo:
    container_name: mongo
    restart: always
    image: mongo:4.2.0
    volumes:
--- a/react-express-mongodb/compose.yaml
+++ b/react-express-mongodb/compose.yaml
@ -9,6 +9,7 @@ services:
    volumes:
      - ./frontend:/usr/src/app
      - /usr/src/app/node_modules
    container_name: frontend
    restart: always
    networks:
      - react-express
@ -16,6 +17,7 @@ services:
      - backend
  backend:
    container_name: backend
    restart: always
    build:
      context: backend
@ -31,6 +33,7 @@ services:
    expose: 
      - 3000
  mongo:
    container_name: mongo
    restart: always
    image: mongo:4.2.0
    volumes:
--- a/sparkjava-mysql/backend/Dockerfile
+++ b/sparkjava-mysql/backend/Dockerfile
@ -1,6 +1,6 @@
 # syntax=docker/dockerfile:1.4
-FROM --platform=$BUILDPLATFORM maven:3.8.5-eclipse-temurin-17 AS build
+FROM --platform=$BUILDPLATFORM maven:3.8.5-eclipse-temurin-17@sha256:a554849fd74b733acb76379bd7df0ea26635a48ab9b54ede1e94bbeaaf448cf6 AS build
 WORKDIR /workdir/server
 COPY pom.xml /workdir/server/pom.xml
 RUN mvn dependency:go-offline
@ -24,7 +24,7 @@ EOF
 COPY --from=gloursdocker/docker / /
 CMD ["java", "-jar", "target/app.jar" ]
-FROM eclipse-temurin:17-jre-focal
+FROM eclipse-temurin:17-jre-focal@sha256:55c1ff40a91898c456dc5a874a66db17b6aa1b4aef8d9cac1ad3b194575638a1
 ARG DEPENDENCY=/workdir/server/target
 EXPOSE 8080
 COPY --from=build ${DEPENDENCY}/app.jar /app.jar
--- a/wasmedge-kafka-mysql/.docker/docker-compose.yml
+++ b/wasmedge-kafka-mysql/.docker/docker-compose.yml
@ -1,36 +0,0 @@
 services:
  redpanda:
    image: docker.redpanda.com/vectorized/redpanda:v22.2.2
    command:
      - redpanda start
      - --smp 1
      - --overprovisioned
      - --node-id 0
      - --kafka-addr PLAINTEXT://0.0.0.0:29092,OUTSIDE://0.0.0.0:9092
      - --advertise-kafka-addr PLAINTEXT://redpanda:29092,OUTSIDE://redpanda:9092
      - --pandaproxy-addr 0.0.0.0:8082
      - --advertise-pandaproxy-addr localhost:8082
    ports:
      - 8081:8081
      - 8082:8082
      - 9092:9092
      - 9644:9644
      - 29092:29092
    volumes:
      - ./kafka:/app
  etl:
    image: etl-kafka
    platform: wasi/wasm
    build:
      context: etl
    environment:
      DATABASE_URL: mysql://root:whalehello@db:3306/mysql
      KAFKA_URL: kafka://redpanda:9092/order
      RUST_BACKTRACE: full
      RUST_LOG: info
    restart: unless-stopped
    runtime: io.containerd.wasmedge.v1
  db:
    image: mariadb:10.9
    environment:
      MYSQL_ROOT_PASSWORD: whalehello
--- a/wasmedge-kafka-mysql/README.md
+++ b/wasmedge-kafka-mysql/README.md
@ -1,117 +0,0 @@
 # Compose sample application
 ![Compatible with Docker+Wasm](../icon_wasm.svg)
 This sample demonstrates a WebAssembly (Wasm) microservice written in Rust. It subscribes to a Kafka queue topic on a Redpanda server, and then transforms and saves each message into a MySQL (MariaDB) database table. The microservice is compiled into Wasm and runs in the WasmEdge runtime, which is a secure and lightweight alternative to natively compiled Rust apps in Linux containers.
 ## Use with Docker Development Environments
 You will need a version of Docker Desktop or Docker CLI with Wasm support.
 * [Install Docker Desktop + Wasm (Beta)](https://docs.docker.com/desktop/wasm/)
 * [Install Docker CLI + Wasm](https://github.com/chris-crone/wasm-day-na-22/tree/main/server)
 ## WasmEdge server with Redpanda and MySQL database
 Project structure:
 ```
 .
 +-- compose.yml
 |-- etl
    |-- Dockerfile
    |-- Cargo.toml
    +-- src
        |-- main.rs
 |-- kafka
    |-- order.json
 |-- db
    |-- db-password.txt
 ```
 The [compose.yml](compose.yml) is as follows.
 ```yaml
 services:
  redpanda:
    image: docker.redpanda.com/vectorized/redpanda:v22.2.2
    command:
      - redpanda start
      - --smp 1
      - --overprovisioned
      - --node-id 0
      - --kafka-addr PLAINTEXT://0.0.0.0:29092,OUTSIDE://0.0.0.0:9092
      - --advertise-kafka-addr PLAINTEXT://redpanda:29092,OUTSIDE://redpanda:9092
      - --pandaproxy-addr 0.0.0.0:8082
      - --advertise-pandaproxy-addr localhost:8082
    ports:
      - 8081:8081
      - 8082:8082
      - 9092:9092
      - 9644:9644
      - 29092:29092
    volumes:
      - ./kafka:/app
  etl:
    image: etl-kafka
    build:
      context: etl
      platforms:
        - wasi/wasm32
    environment:
      DATABASE_URL: mysql://root:whalehello@db:3306/mysql
      KAFKA_URL: kafka://redpanda:9092/order
      RUST_BACKTRACE: full
      RUST_LOG: info
    restart: unless-stopped
    runtime: io.containerd.wasmedge.v1
  db:
    image: mariadb:10.9
    environment:
      MYSQL_ROOT_PASSWORD: whalehello
 ```
 The compose file defines an application with three services `redpanda`, `etl` and `db`. The `redpanda` service is a Kafka-compatible messaging server that produces messages in a queue topic. The `etl` service, in the WasmEdge container that subscribes to the queue topic and receives incoming messages. Each incoming message is parsed and stored in the `db` MySQL (MariaDB) database server.
 ## Deploy with docker compose
 ```bash
 $ docker compose up -d
 ...
 ⠿ Network wasmedge-kafka-mysql_default       Created                      0.1s
 ⠿ Container wasmedge-kafka-mysql-redpanda-1  Created                      0.3s
 ⠿ Container wasmedge-kafka-mysql-etl-1       Created                      0.3s
 ⠿ Container wasmedge-kafka-mysql-db-1        Created                      0.3s
 ```
 ## Expected result
 ```bash
 $ docker compose ps
 NAME                              COMMAND                  SERVICE             STATUS              PORTS
 wasmedge-kafka-mysql-db-1         "docker-entrypoint.s…"   db                  running             3306/tcp
 wasmedge-kafka-mysql-etl-1        "kafka.wasm"             etl                 running
 wasmedge-kafka-mysql-redpanda-1   "/entrypoint.sh 'red…"   redpanda            running             0.0.0.0:8081-8082->8081-8082/tcp, :::8081-8082->8081-8082/tcp, 0.0.0.0:9092->9092/tcp, :::9092->9092/tcp, 0.0.0.0:9644->9644/tcp, :::9644->9644/tcp, 0.0.0.0:29092->29092/tcp, :::29092->29092/tcp
 ```
 After the application starts, 
 log into the Redpanda container and send a message to the queue topic `order` as follows.
 ```bash
 $ docker compose exec redpanda /bin/bash
 redpanda@1add2615774b:/$ cd /app
 redpanda@1add2615774b:/app$ cat order.json | rpk topic produce order
 Produced to partition 0 at offset 0 with timestamp 1667922788523.
 ```
 To see the data in the database container, you can use the following commands.
 ```bash
 $ docker compose exec db /bin/bash
 root@c97c472db02e:/# mysql -u root -pwhalehello mysql
 mysql> select * from orders;
 ... ...
 ```
--- a/wasmedge-kafka-mysql/compose.yml
+++ b/wasmedge-kafka-mysql/compose.yml
@ -1,36 +0,0 @@
 services:
  redpanda:
    image: docker.redpanda.com/vectorized/redpanda:v22.2.2
    command:
      - redpanda start
      - --smp 1
      - --overprovisioned
      - --node-id 0
      - --kafka-addr PLAINTEXT://0.0.0.0:29092,OUTSIDE://0.0.0.0:9092
      - --advertise-kafka-addr PLAINTEXT://redpanda:29092,OUTSIDE://redpanda:9092
      - --pandaproxy-addr 0.0.0.0:8082
      - --advertise-pandaproxy-addr localhost:8082
    ports:
      - 8081:8081
      - 8082:8082
      - 9092:9092
      - 9644:9644
      - 29092:29092
    volumes:
      - ./kafka:/app
  etl:
    image: etl-kafka
    platform: wasi/wasm
    build:
      context: etl
    environment:
      DATABASE_URL: mysql://root:whalehello@db:3306/mysql
      KAFKA_URL: kafka://redpanda:9092/order
      RUST_BACKTRACE: full
      RUST_LOG: info
    restart: unless-stopped
    runtime: io.containerd.wasmedge.v1
  db:
    image: mariadb:10.9
    environment:
      MYSQL_ROOT_PASSWORD: whalehello
--- a/wasmedge-kafka-mysql/db/db-password.txt
+++ b/wasmedge-kafka-mysql/db/db-password.txt
@ -1 +0,0 @@
 whalehello
--- a/wasmedge-kafka-mysql/etl/Cargo.toml
+++ b/wasmedge-kafka-mysql/etl/Cargo.toml
@ -1,17 +0,0 @@
 [package]
 name = "kafka"
 version = "0.1.0"
 edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
 anyhow = "1.0.65"
 mega_etl = {git = "https://github.com/second-state/MEGA.git"}
 tokio_wasi = {version = '1.21', features = ["rt", "macros"]}
 env_logger = "0.9"
 log  = "0.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 http_req_wasi  = "0.10"
 lazy_static = "1.4.0"
--- a/wasmedge-kafka-mysql/etl/Dockerfile
+++ b/wasmedge-kafka-mysql/etl/Dockerfile
@ -1,27 +0,0 @@
 # syntax=docker/dockerfile:1
 FROM --platform=$BUILDPLATFORM rust:1.64 AS buildbase
 RUN <<EOT bash
    set -ex
    apt-get update
    apt-get install -y \
        git \
        clang
    rustup target add wasm32-wasi
 EOT
 # This line installs WasmEdge including the AOT compiler
 RUN curl -sSf https://raw.githubusercontent.com/WasmEdge/WasmEdge/master/utils/install.sh | bash
 FROM buildbase AS build
 COPY Cargo.toml .
 COPY src ./src 
 # Build the Wasm binary
 RUN --mount=type=cache,target=/usr/local/cargo/git/db \
    --mount=type=cache,target=/usr/local/cargo/registry/cache \
    --mount=type=cache,target=/usr/local/cargo/registry/index \
    cargo build --target wasm32-wasi --release
 # This line builds the AOT Wasm binary
 RUN /root/.wasmedge/bin/wasmedgec target/wasm32-wasi/release/kafka.wasm kafka.wasm
 FROM scratch
 ENTRYPOINT [ "kafka.wasm" ]
 COPY --link --from=build /kafka.wasm /kafka.wasm
--- a/wasmedge-kafka-mysql/etl/src/main.rs
+++ b/wasmedge-kafka-mysql/etl/src/main.rs
@ -1,58 +0,0 @@
 use mega_etl::{async_trait, Pipe, Transformer, TransformerError, TransformerResult};
 use serde::{Deserialize, Serialize};
 #[derive(Serialize, Deserialize, Debug)]
 struct Order {
    order_id: i32,
    product_id: i32,
    quantity: i32,
    amount: f32,
    shipping: f32,
    tax: f32,
    shipping_address: String,
 }
 #[async_trait]
 impl Transformer for Order {
    async fn transform(inbound_data: &Vec<u8>) -> TransformerResult<Vec<String>> {
        let s = std::str::from_utf8(&inbound_data)
            .map_err(|e| TransformerError::Custom(e.to_string()))?;
        let order: Order = serde_json::from_str(String::from(s).as_str())
            .map_err(|e| TransformerError::Custom(e.to_string()))?;
        log::info!("{:?}", &order);
        let mut ret = vec![];
        let sql_string = format!(
            r"INSERT INTO orders VALUES ({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, CURRENT_TIMESTAMP);",
            order.order_id,
            order.product_id,
            order.quantity,
            order.amount,
            order.shipping,
            order.tax,
            order.shipping_address,
        );
        dbg!(sql_string.clone());
        ret.push(sql_string);
        Ok(ret)
    }
    async fn init() -> TransformerResult<String> {
        Ok(String::from(
            r"CREATE TABLE IF NOT EXISTS orders (order_id INT, product_id INT, quantity INT, amount FLOAT, shipping FLOAT, tax FLOAT, shipping_address VARCHAR(50), date_registered TIMESTAMP DEFAULT CURRENT_TIMESTAMP);",
        ))
    }
 }
 #[tokio::main(flavor = "current_thread")]
 async fn main() -> anyhow::Result<()> {
    env_logger::init();
    // can use builder later
    let database_uri = std::env::var("DATABASE_URL")?;
    let kafka_uri = std::env::var("KAFKA_URL")?;
    let mut pipe = Pipe::new(database_uri, kafka_uri).await;
    // This is async because this calls the async transform() function in Order
    pipe.start::<Order>().await?;
    Ok(())
 }
--- a/wasmedge-kafka-mysql/kafka/order.json
+++ b/wasmedge-kafka-mysql/kafka/order.json
@ -1 +0,0 @@
 {"order_id": 1,"product_id": 12,"quantity": 2,"amount": 56.0,"shipping": 15.0,"tax": 2.0,"shipping_address": "Mataderos 2312"}
--- a/wasmedge-mysql-nginx/.docker/docker-compose.yml
+++ b/wasmedge-mysql-nginx/.docker/docker-compose.yml
@ -1,25 +0,0 @@
 services:
  frontend:
    image: nginx:alpine
    ports:
      - 8090:80
    volumes:
      - ./frontend:/usr/share/nginx/html
  backend:
    image: demo-microservice
    platform: wasi/wasm
    build:
      context: backend/
    ports:
      - 8080:8080
    environment:
      DATABASE_URL: mysql://root:whalehello@db:3306/mysql
      RUST_BACKTRACE: full
    restart: unless-stopped
    runtime: io.containerd.wasmedge.v1
  db:
    image: mariadb:10.9
    environment:
      MYSQL_ROOT_PASSWORD: whalehello
--- a/wasmedge-mysql-nginx/README.md
+++ b/wasmedge-mysql-nginx/README.md
@ -1,125 +0,0 @@
 # Compose sample application
 ![Compatible with Docker+Wasm](../icon_wasm.svg)
 This sample demonstrates a web application with a WebAssembly (Wasm) microservice, written in Rust. The Wasm microservice is an HTTP API connected to a MySQL (MariaDB) database. The API is invoked via from JavaScript in a web interface serving static HTML. The microservice is compiled into WebAssembly (Wasm) and runs in the WasmEdge Runtime, a secure and lightweight alternative to natively compiled Rust apps in Linux containers. Checkout [this article](https://blog.logrocket.com/rust-microservices-server-side-webassembly/) or [this video](https://www.youtube.com/watch?v=VSqMPFr7SEs) to learn how the Rust code in this microservice works.
 ## Use with Docker Development Environments
 You will need a version of Docker Desktop or Docker CLI with Wasm support.
 * [Install Docker Desktop + Wasm (Beta)](https://docs.docker.com/desktop/wasm/)
 * [Install Docker CLI + Wasm](https://github.com/chris-crone/wasm-day-na-22/tree/main/server)
 ## WasmEdge server with Nginx proxy and MySQL database
 Project structure:
 ```
 .
 +-- compose.yml
 |-- backend
    +-- Dockerfile
    |-- Cargo.toml
    |-- src
        +-- main.rs
 |-- frontend
    +-- index.html
    |-- js
        +-- app.js
 |-- db
    +-- orders.json
    |-- update_order.json
 ```
 The [compose.yml](compose.yml) file:
 ```yaml
 services:
  frontend:
    image: nginx:alpine
    ports:
      - 8090:80
    volumes:
      - ./frontend:/usr/share/nginx/html
  backend:
    image: demo-microservice
    build:
      context: backend/
      platforms:
        - wasi/wasm32
    ports:
      - 8080:8080
    environment:
      DATABASE_URL: mysql://root:whalehello@db:3306/mysql
      RUST_BACKTRACE: full
    restart: unless-stopped
    runtime: io.containerd.wasmedge.v1
  db:
    image: mariadb:10.9
    environment:
      MYSQL_ROOT_PASSWORD: whalehello
 ```
 The compose file defines an application with three services `frontend`, `backend` and `db`. The `frontend` is a simple Nginx server that hosts static web pages that access the `backend` web service, in the WasmEdge container, via HTTP port 8080. When deploying the application, docker compose maps port 8090 of the `frontend` service container to port 8090 of the host as specified in the file. Make sure that ports 8090 and 8080 on the host are not already being used.
 ## Deploy with docker compose
 ```bash
 $ docker compose up -d
 ...
 ⠿ Network wasmedge-mysql-nginx_default       Created
 ⠿ Container wasmedge-mysql-nginx-db-1        Created
 ⠿ Container wasmedge-mysql-nginx-frontend-1  Created
 ⠿ Container wasmedge-mysql-nginx-backend-1   Created
 ```
 ## Expected result
 ```bash
 $ docker compose ps
 NAME                              COMMAND                  SERVICE             STATUS              PORTS
 wasmedge-mysql-nginx-backend-1    "order_demo_service.…"   backend             running             0.0.0.0:8080->8080/tcp, :::8080->8080/tcp
 wasmedge-mysql-nginx-db-1         "docker-entrypoint.s…"   db                  running             3306/tcp
 wasmedge-mysql-nginx-frontend-1   "/docker-entrypoint.…"   frontend            running             0.0.0.0:8090->80/tcp, :::8090->80/tcp
 ```
 After the application starts, go to `http://localhost:8090` in your web browser to display the web frontend. 
 ### Using the API with `curl`
 As an alternative to the web frontend, you can use `curl` to interact with the WasmEdge API directly (the `backend` service).
 When the WasmEdge web service receives a GET request to the `/init` endpoint, it would initialize the database with the `orders` table.
 ```bash
 curl http://localhost:8080/init
 ```
 When the WasmEdge web service receives a POST request to the `/create_order` endpoint, it extracts the JSON data from the POST body and inserts an `Order` record into the database table.
 To insert multiple records, use the `/create_orders` endpoint and POST a JSON array of `Order` objects:
 ```bash
 curl http://localhost:8080/create_orders -X POST -d @db/orders.json
 ```
 When the WasmEdge web service receives a GET request to the `/orders` endpoint, it gets all rows from the `orders` table and return the result set in a JSON array in the HTTP response.
 ```bash
 curl http://localhost:8080/orders
 ```
 When the WasmEdge web service receives a POST request to the `/update_order` endpoint, it extracts the JSON data from the POST body and update the `Order` record in the database table that matches the `order_id` in the input data.
 ```bash
 curl http://localhost:8080/update_order -X POST -d @db/update_order.json
 ```
 When the WasmEdge web service receives a GET request to the `/delete_order` endpoint, it deletes the row in the `orders` table that matches the `id` GET parameter.
 ```bash
 curl http://localhost:8080/delete_order?id=2
 ```
--- a/wasmedge-mysql-nginx/backend/Cargo.toml
+++ b/wasmedge-mysql-nginx/backend/Cargo.toml
@ -1,13 +0,0 @@
 [package]
 name = "order_demo_service"
 version = "0.1.0"
 edition = "2021"
 [dependencies]
 anyhow = "1.0"
 serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 url = "2.3"
 mysql_async_wasi = "0.30"
 hyper_wasi = { version = "0.15", features = ["full"] }
 tokio_wasi = { version = "1", features = ["io-util", "fs", "net", "time", "rt", "macros"] }
--- a/wasmedge-mysql-nginx/backend/Dockerfile
+++ b/wasmedge-mysql-nginx/backend/Dockerfile
@ -1,29 +0,0 @@
 # syntax=docker/dockerfile:1
 FROM --platform=$BUILDPLATFORM rust:1.64 AS buildbase
 WORKDIR /src
 RUN <<EOT bash
    set -ex
    apt-get update
    apt-get install -y \
        git \
        clang
    rustup target add wasm32-wasi
 EOT
 # This line installs WasmEdge including the AOT compiler
 RUN curl -sSf https://raw.githubusercontent.com/WasmEdge/WasmEdge/master/utils/install.sh | bash
 FROM buildbase AS build
 COPY Cargo.toml .
 COPY src ./src 
 # Build the Wasm binary
 RUN --mount=type=cache,target=/usr/local/cargo/git/db \
    --mount=type=cache,target=/usr/local/cargo/registry/cache \
    --mount=type=cache,target=/usr/local/cargo/registry/index \
    cargo build --target wasm32-wasi --release
 # This line builds the AOT Wasm binary
 RUN /root/.wasmedge/bin/wasmedgec target/wasm32-wasi/release/order_demo_service.wasm order_demo_service.wasm
 FROM scratch
 ENTRYPOINT [ "order_demo_service.wasm" ]
 COPY --link --from=build /src/order_demo_service.wasm /order_demo_service.wasm
--- a/wasmedge-mysql-nginx/backend/src/main.rs
+++ b/wasmedge-mysql-nginx/backend/src/main.rs
@ -1,237 +0,0 @@
 use hyper::service::{make_service_fn, service_fn};
 use hyper::{Body, Method, Request, Response, StatusCode, Server};
 pub use mysql_async::prelude::*;
 pub use mysql_async::*;
 use std::convert::Infallible;
 use std::net::SocketAddr;
 use std::result::Result;
 use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 fn get_url() -> String {
    if let Ok(url) = std::env::var("DATABASE_URL") {
        let opts = Opts::from_url(&url).expect("DATABASE_URL invalid");
        if opts
            .db_name()
            .expect("a database name is required")
            .is_empty()
        {
            panic!("database name is empty");
        }
        url
    } else {
        "mysql://root:pass@127.0.0.1:3306/mysql".into()
    }
 }
 #[derive(Serialize, Deserialize, Debug)]
 struct Order {
    order_id: i32,
    product_id: i32,
    quantity: i32,
    amount: f32,
    shipping: f32,
    tax: f32,
    shipping_address: String,
 }
 impl Order {
    fn new(
        order_id: i32,
        product_id: i32,
        quantity: i32,
        amount: f32,
        shipping: f32,
        tax: f32,
        shipping_address: String,
    ) -> Self {
        Self {
            order_id,
            product_id,
            quantity,
            amount,
            shipping,
            tax,
            shipping_address,
        }
    }
 }
 async fn handle_request(req: Request<Body>, pool: Pool) -> Result<Response<Body>, anyhow::Error> {
    match (req.method(), req.uri().path()) {
        (&Method::GET, "/") => Ok(Response::new(Body::from(
            "The valid endpoints are /init /create_order /create_orders /update_order /orders /delete_order",
        ))),
        // Simply echo the body back to the client.
        (&Method::POST, "/echo") => Ok(Response::new(req.into_body())),
        // CORS OPTIONS
        (&Method::OPTIONS, "/init") => Ok(response_build(&String::from(""))),
        (&Method::OPTIONS, "/create_order") => Ok(response_build(&String::from(""))),
        (&Method::OPTIONS, "/create_orders") => Ok(response_build(&String::from(""))),
        (&Method::OPTIONS, "/update_order") => Ok(response_build(&String::from(""))),
        (&Method::OPTIONS, "/delete_order") => Ok(response_build(&String::from(""))),
        (&Method::OPTIONS, "/orders") => Ok(response_build(&String::from(""))),
        (&Method::GET, "/init") => {
            let mut conn = pool.get_conn().await.unwrap();
            "DROP TABLE IF EXISTS orders;".ignore(&mut conn).await?;
            "CREATE TABLE orders (order_id INT, product_id INT, quantity INT, amount FLOAT, shipping FLOAT, tax FLOAT, shipping_address VARCHAR(20));".ignore(&mut conn).await?;
            drop(conn);
            Ok(response_build("{\"status\":true}"))
        }
        (&Method::POST, "/create_order") => {
            let mut conn = pool.get_conn().await.unwrap();
            let byte_stream = hyper::body::to_bytes(req).await?;
            let order: Order = serde_json::from_slice(&byte_stream).unwrap();
            "INSERT INTO orders (order_id, product_id, quantity, amount, shipping, tax, shipping_address) VALUES (:order_id, :product_id, :quantity, :amount, :shipping, :tax, :shipping_address)"
                .with(params! {
                    "order_id" => order.order_id,
                    "product_id" => order.product_id,
                    "quantity" => order.quantity,
                    "amount" => order.amount,
                    "shipping" => order.shipping,
                    "tax" => order.tax,
                    "shipping_address" => &order.shipping_address,
                })
                .ignore(&mut conn)
                .await?;
            drop(conn);
            Ok(response_build("{\"status\":true}"))
        }
        (&Method::POST, "/create_orders") => {
            let mut conn = pool.get_conn().await.unwrap();
            let byte_stream = hyper::body::to_bytes(req).await?;
            let orders: Vec<Order> = serde_json::from_slice(&byte_stream).unwrap();
            "INSERT INTO orders (order_id, product_id, quantity, amount, shipping, tax, shipping_address) VALUES (:order_id, :product_id, :quantity, :amount, :shipping, :tax, :shipping_address)"
                .with(orders.iter().map(|order| {
                    params! {
                        "order_id" => order.order_id,
                        "product_id" => order.product_id,
                        "quantity" => order.quantity,
                        "amount" => order.amount,
                        "shipping" => order.shipping,
                        "tax" => order.tax,
                        "shipping_address" => &order.shipping_address,
                    }
                }))
                .batch(&mut conn)
                .await?;
            drop(conn);
            Ok(response_build("{\"status\":true}"))
        }
        (&Method::POST, "/update_order") => {
            let mut conn = pool.get_conn().await.unwrap();
            let byte_stream = hyper::body::to_bytes(req).await?;
            let order: Order = serde_json::from_slice(&byte_stream).unwrap();
            "UPDATE orders SET product_id=:product_id, quantity=:quantity, amount=:amount, shipping=:shipping, tax=:tax, shipping_address=:shipping_address WHERE order_id=:order_id"
                .with(params! {
                    "product_id" => order.product_id,
                    "quantity" => order.quantity,
                    "amount" => order.amount,
                    "shipping" => order.shipping,
                    "tax" => order.tax,
                    "shipping_address" => &order.shipping_address,
                    "order_id" => order.order_id,
                })
                .ignore(&mut conn)
                .await?;
            drop(conn);
            Ok(response_build("{\"status\":true}"))
        }
        (&Method::GET, "/orders") => {
            let mut conn = pool.get_conn().await.unwrap();
            let orders = "SELECT * FROM orders"
                .with(())
                .map(&mut conn, |(order_id, product_id, quantity, amount, shipping, tax, shipping_address)| {
                    Order::new(
                        order_id,
                        product_id,
                        quantity,
                        amount,
                        shipping,
                        tax,
                        shipping_address,
                    )},
                ).await?;
            drop(conn);
            Ok(response_build(serde_json::to_string(&orders)?.as_str()))
        }        
        (&Method::GET, "/delete_order") => {
            let mut conn = pool.get_conn().await.unwrap();
            let params: HashMap<String, String> = req.uri().query().map(|v| {
                url::form_urlencoded::parse(v.as_bytes()).into_owned().collect()
            }).unwrap_or_else(HashMap::new);
            let order_id = params.get("id");
            "DELETE FROM orders WHERE order_id=:order_id"
                .with(params! { "order_id" => order_id, })
                .ignore(&mut conn)
                .await?;
            drop(conn);
            Ok(response_build("{\"status\":true}"))
        }
        // Return the 404 Not Found for other routes.
        _ => {
            let mut not_found = Response::default();
            *not_found.status_mut() = StatusCode::NOT_FOUND;
            Ok(not_found)
        }
    }
 }
 // CORS headers
 fn response_build(body: &str) -> Response<Body> {
    Response::builder()
        .header("Access-Control-Allow-Origin", "*")
        .header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
        .header("Access-Control-Allow-Headers", "api,Keep-Alive,User-Agent,Content-Type")
        .body(Body::from(body.to_owned()))
        .unwrap()
 }
 #[tokio::main(flavor = "current_thread")]
 async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let opts = Opts::from_url(&*get_url()).unwrap();
    let builder = OptsBuilder::from_opts(opts);
    // The connection pool will have a min of 5 and max of 10 connections.
    let constraints = PoolConstraints::new(5, 10).unwrap();
    let pool_opts = PoolOpts::default().with_constraints(constraints);
    let pool = Pool::new(builder.pool_opts(pool_opts));
    let addr = SocketAddr::from(([0, 0, 0, 0], 8080));
    let make_svc = make_service_fn(|_| {
        let pool = pool.clone();
        async move {
            Ok::<_, Infallible>(service_fn(move |req| {
                let pool = pool.clone();
                handle_request(req, pool)
            }))
        }
    });
    let server = Server::bind(&addr).serve(make_svc);
    if let Err(e) = server.await {
        eprintln!("server error: {}", e);
    }
    Ok(())
 }
--- a/wasmedge-mysql-nginx/compose.yml
+++ b/wasmedge-mysql-nginx/compose.yml
@ -1,25 +0,0 @@
 services:
  frontend:
    image: nginx:alpine
    ports:
      - 8090:80
    volumes:
      - ./frontend:/usr/share/nginx/html
  backend:
    image: demo-microservice
    platform: wasi/wasm
    build:
      context: backend/
    ports:
      - 8080:8080
    environment:
      DATABASE_URL: mysql://root:whalehello@db:3306/mysql
      RUST_BACKTRACE: full
    restart: unless-stopped
    runtime: io.containerd.wasmedge.v1
  db:
    image: mariadb:10.9
    environment:
      MYSQL_ROOT_PASSWORD: whalehello
--- a/wasmedge-mysql-nginx/db/orders.json
+++ b/wasmedge-mysql-nginx/db/orders.json
@ -1,47 +0,0 @@
 [
  {
    "order_id": 1,
    "product_id": 12,
    "quantity": 2,
    "amount": 56.0,
    "shipping": 15.0,
    "tax": 2.0,
    "shipping_address": "Mataderos 2312"
  },
  {
    "order_id": 2,
    "product_id": 15,
    "quantity": 3,
    "amount": 256.0,
    "shipping": 30.0,
    "tax": 16.0,
    "shipping_address": "1234 NW Bobcat"
  },
  {
    "order_id": 3,
    "product_id": 11,
    "quantity": 5,
    "amount": 536.0,
    "shipping": 50.0,
    "tax": 24.0,
    "shipping_address": "20 Havelock"
  },
  {
    "order_id": 4,
    "product_id": 8,
    "quantity": 8,
    "amount": 126.0,
    "shipping": 20.0,
    "tax": 12.0,
    "shipping_address": "224 Pandan Loop"
  },
  {
    "order_id": 5,
    "product_id": 24,
    "quantity": 1,
    "amount": 46.0,
    "shipping": 10.0,
    "tax": 2.0,
    "shipping_address": "No.10 Jalan Besar"
  }
 ]
--- a/wasmedge-mysql-nginx/db/update_order.json
+++ b/wasmedge-mysql-nginx/db/update_order.json
@ -1,9 +0,0 @@
 {
    "order_id": 3,
    "product_id": 12,
    "quantity": 2,
    "amount": 56.0,
    "shipping": 15.0,
    "tax": 2.0,
    "shipping_address": "123 Main Street"
 }
--- a/wasmedge-mysql-nginx/frontend/index.html
+++ b/wasmedge-mysql-nginx/frontend/index.html
@ -1,102 +0,0 @@
 <!DOCTYPE html>
 <html>
 <head>
  <title>Demo App</title>
  <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.2.2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-Zenh87qX5JnK2Jl0vWa8Ck2rdkQ2Bzep5IDxbcnCeuOxjzrPF/et3URy9Bv1WTRi" crossorigin="anonymous" />
  <style>.d-none { display: none; }</style>
 </head>
 <body class="mb-5">
  <div class="container mt-5">
    <div id="app-loading-display">
      <h1>Loading...</h1>
    </div>
    <div id="order-display" class="d-none">
      <h1>Welcome to the Demo!</h1>
      <p>This application is served using nginx for the website, Wasm for the backend, and MariaDB for the database.</p>
      <div id="order-empty-text" class="d-none">
        <em>There are currently no orders to display!</em>
      </div>
      <table id="order-table" class="d-none table table-striped">
        <thead>
          <tr>
            <th>Id</th>
            <th>Product Id</th>
            <th>Quantity</th>
            <th>Amount</th>
            <th>Shipping</th>
            <th>Tax</th>
            <th>Address</th>
            <th></th>
          </tr>
        </thead>
        <tbody></tbody>
      </table>
      <hr />
      <div id="add-order-wrapper" class="d-none row">
        <div class="col-6">
         <div class="accordion" id="accordionExample">
            <div class="accordion-item">
              <h2 class="accordion-header" id="addOrderHeading">
                <button class="accordion-button collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#addOrder" aria-controls="addOrder">
                  Add an order
                </button>
              </h2>
              <div id="addOrder" class="accordion-collapse collapse p-3" aria-labelledby="addOrderHeading" data-bs-parent="#accordionExample">
                <form id="add-order-form">
                  <div class="mb-3">
                    <label for="order-id" class="form-label">Order Id</label>
                    <input type="number" required class="form-control" id="order-id" aria-describedby="orderIdHelp">
                    <div id="orderIdHelp" class="form-text">The ID of the order</div>
                  </div>
                  <div class="mb-3">
                    <label for="product-id" class="form-label">Product Id</label>
                    <input type="number" required class="form-control" id="product-id" aria-describedby="productIdHelp">
                    <div id="productIdHelp" class="form-text">The ID of the product</div>
                  </div>
                  <div class="mb-3">
                    <label for="quantity" class="form-label">Quantity</label>
                    <input type="number" required class="form-control" id="quantity" aria-describedby="quantityHelp">
                    <div id="quantityHelp" class="form-text">How many of the product?</div>
                  </div>
                  <div class="mb-3">
                    <label for="amount" class="form-label">Amount</label>
                    <input type="number" required class="form-control" id="amount" aria-describedby="amountHelp">
                    <div id="amountHelp" class="form-text">The total amount</div>
                  </div>
                  <div class="mb-3">
                    <label for="tax" class="form-label">Tax</label>
                    <input type="number" required class="form-control" id="tax" aria-describedby="taxHelp">
                    <div id="taxHelp" class="form-text">The total amount of tax</div>
                  </div>
                  <div class="mb-3">
                    <label for="shippingAmount" class="form-label">Shipping Amount</label>
                    <input type="number" required class="form-control" id="shippingAmount" aria-describedby="shippingAmountHelp">
                    <div id="shippingAmountHelp" class="form-text">The total amount for shipping</div>
                  </div>
                  <div class="mb-3">
                    <label for="shippingAddress" class="form-label">Shipping Address</label>
                    <input type="text" required class="form-control" id="shippingAddress" aria-describedby="addressHelp">
                    <div id="addressHelp" class="form-text">Where to send the order</div>
                  </div>
                  <input type="submit" class="btn btn-success" value="Add Order" />
                </form>
              </div>
            </div>
          </div>
        </div>
      </div>
    </div>
  </div>
  <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.2.2/dist/js/bootstrap.bundle.min.js" integrity="sha384-OERcA2EqjJCMA+/3y+gxIOqMEjwtxJY7qPCqsdltbNJuaOe923+mo//f6V8Qbsw3" crossorigin="anonymous"></script>
  <script type="text/javascript" src="/js/app.js"></script>
 </body>
 </html>
--- a/wasmedge-mysql-nginx/frontend/js/app.js
+++ b/wasmedge-mysql-nginx/frontend/js/app.js
@ -1,135 +0,0 @@
 (function() {
  let orders = null;
  const appLoadingEle = document.getElementById("app-loading-display");
  const orderWrapperEle = document.getElementById("order-display");
  const orderEmptyTextEle = document.getElementById("order-empty-text");
  const orderTableEle = document.getElementById("order-table");
  const orderTableBodyEle = document.querySelector("#order-table tbody");
  const addOrderEle = document.getElementById("add-order-wrapper");
  const addOrderForm = document.getElementById("add-order-form");
  const orderIdField = document.getElementById("order-id");
  const productIdField = document.getElementById("product-id");
  const quantityField = document.getElementById("quantity");
  const amountField = document.getElementById("amount");
  const taxField = document.getElementById("tax");
  const shippingField = document.getElementById("shippingAmount");
  const shippingAddressField = document.getElementById("shippingAddress");
  function fetchOrders() {
    fetch("http://localhost:8080/orders")
      .then(r => r.json())
      .then(r => orders = r)
      .then(renderOrders)
      .catch((e) => {
        init();
      });
  }
  function init() {
    fetch("http://localhost:8080/init")
      .then(() => fetchOrders())
      .catch((e) => displayError(e));
  }
  function renderOrders() {
    appLoadingEle.classList.add("d-none");
    orderWrapperEle.classList.remove("d-none");
    addOrderEle.classList.remove("d-none");
    if (orders.length === 0) {
      orderEmptyTextEle.classList.remove("d-none");
      orderTableEle.classList.add("d-none");
      return;
    }
    orderEmptyTextEle.classList.add("d-none");
    orderTableEle.classList.remove("d-none");
    while (orderTableBodyEle.firstChild) {
      orderTableBodyEle.removeChild(orderTableBodyEle.firstChild);
    }
    orders.forEach((order) => {
      const orderId = order.order_id;
      const row = document.createElement("tr");
      row.appendChild(createCell(order.order_id));
      row.appendChild(createCell(order.product_id));
      row.appendChild(createCell(order.quantity));
      row.appendChild(createCell(order.amount));
      row.appendChild(createCell(order.shipping));
      row.appendChild(createCell(order.tax));
      row.appendChild(createCell(order.shipping_address));
      const actionCell = document.createElement("td");
      const deleteButton = document.createElement("button");
      deleteButton.classList.add(...["btn","btn-sm","btn-danger"]);
      deleteButton.innerText = "Delete";
      deleteButton.addEventListener("click", (e) => {
        e.preventDefault();
        deleteOrder(orderId);
      });
      actionCell.appendChild(deleteButton);
      row.appendChild(actionCell);
      orderTableBodyEle.appendChild(row);
    });
  }
  function createCell(contents) {
    const cell = document.createElement("td");
    cell.innerText = contents;
    return cell;
  }
  function deleteOrder(orderId) {
    fetch(`http://localhost:8080/delete_order?id=${orderId}`)
      .then(() => fetchOrders());
  }
  function displayError(err) {
    alert("Error:" + err);
  }
  function onAddFormSubmit(e) {
    e.preventDefault();
    const data = {
      order_id : parseFloat(orderIdField.value),
      product_id : parseFloat(productIdField.value),
      quantity : parseFloat(quantityField.value),
      amount : parseFloat(amountField.value),
      shipping : parseFloat(shippingField.value),
      tax : parseFloat(taxField.value),
      shipping_address : shippingAddressField.value,
    };
    fetch("http://localhost:8080/create_order", {
      method: "POST",
      body: JSON.stringify(data),
      headers: { "Content-type": "application/json" },
    }).then(() => fetchOrders())
      .then(() => resetAddOrderForm());
    alert("Order added");
  }
  function resetAddOrderForm() {
    orderIdField.value = "";
    productIdField.value = "";
    quantityField.value = "";
    amountField.value = "";
    shippingField.value = "";
    taxField.value = "";
    shippingAddressField.value = "";
  }
  fetchOrders();
  addOrderForm.addEventListener("submit", onAddFormSubmit);
 })();
		`@ -1 +0,0 @@`
			`{"order_id": 1,"product_id": 12,"quantity": 2,"amount": 56.0,"shipping": 15.0,"tax": 2.0,"shipping_address": "Mataderos 2312"}`