```sh
podman run -p 9000:9000 -p 9001:9001 \
  quay.io/minio/minio server /data --console-address ":9001"
```

The MinIO deployment starts using default root credentials `minioadmin:minioadmin`. You can test the deployment using the MinIO Console, an embedded

You can see that:

* The Gunicorn **process manager** starts with PID `19499` (in your case it will be a different number).
* Then it starts `Listening at: http://0.0.0.0:80`.
* Then it detects that it has to use the worker class at `uvicorn.workers.UvicornWorker`.
* And then it starts **4 workers**, each with its own PID: `19511`, `19513`, `19514`, and `19515`.

#     ; beforeUpdateMap = map:{
#         ; UPDATE_DATETIME   = $$AccessContext$$.getAccessLocalDateTimeOnThread()
#         ; UPDATE_USER       = $$AccessContext$$.getAccessUserOnThread()
#     }
# }
#
# *The line that starts with '#' means comment-out.
#
map:{
    #; commonColumnMap = map:{
    #    ; REGISTER_DATETIME=TIMESTAMP ; REGISTER_USER=VARCHAR
    #    ; UPDATE_DATETIME=TIMESTAMP   ; UPDATE_USER=VARCHAR
    #}

#             ; where=[condition for select]; orderBy=[column-name for ordering]
#             ; exceptCodeList=[the list of except code]
#         }
#     }
# }
#
# *The line that starts with '#' means comment-out.
#
map:{
    # example for implicit classification
    #; Flg = list:{
    #    ; map:{topComment=general boolean classification for every flg-column; codeType=Number}

Construction should NOT actually start running all of these things, do I/O, or block in anyway.

Running the controller actually starts processing things.
Normally, this just means running the queue.
All informers created by `kube.Client` are kept track in the client, and started in one go with `RunAndWait` in one centralized call.

   * replaced with [setDispatcher][dispatcher].
   */
  fun enqueue(response: MockResponse) = (dispatcher as QueueDispatcher).enqueueResponse(response)

  /**
   * Starts the server on the loopback interface for the given port.
   *
   * @param port the port to listen to, or 0 for any available port. Automated tests should always

#             ; freeGenList = list:{ [env or config or label or message or html] }
#             ; propertiesHtmlList = list:{ [env or config or label or message] }
#         }
#     }
# }
#
# *The line that starts with '#' means comment-out.
#
map:{
    # your service name, camel case, initial uncapitalised
    ; serviceName = fess

    # package for your domain name, e.g. com.example
    ; domainPackage = org.codelibs.fess

You can read more about this in the [Advanced User Guide](../advanced/index.md){.internal-link target=_blank}.

## Details

The first `"/static"` refers to the sub-path this "sub-application" will be "mounted" on. So, any path that starts with `"/static"` will be handled by it.

The `directory="static"` refers to the name of the directory that contains your static files.

The `name="static"` gives it a name that can be used internally by **FastAPI**.

      val rangeLimit =
        when {
          r + 1 < rangesOffsets.size -> rangesOffsets[r + 1] * 4
          else -> rangesOffsets.size * 4
        }

      // Confirm this range starts with byte 0.
      assertThat(compactTable.ranges[rangePos].code).isEqualTo(0)

      // Confirm this range's index byte is increasing.
      val rangeStarts = mutableListOf<Int>()

And if your remote server or virtual machine only has 3 GB of RAM, trying to load more than 4 GB of RAM will cause problems. 🚨

### Multiple Processes - An Example

In this example, there's a **Manager Process** that starts and controls two **Worker Processes**.

This Manager Process would probably be the one listening on the **port** in the IP. And it would transmit all the communication to the worker processes.