From Zero to Container Hero

1. Search for the official container of your application;

2. Choose a database and user name and generate a password;

3. Write or copy a compose.yaml (or Dockerfile) to deploy:

• The Application;
• Database;
• Reverse Proxy;
• Certbot;

4. Make sure your compose file is:

• Linking the database to the application container;
• Using depends_on in the correct order;
• Passing the correct env variables, including the secrets;
• Setting the right ports and entrypoints;
• Creating a shared volume between the reverse proxy and the certbot;

5. Configure the NGINX reverse proxy with your domain. Create the root location to proxy the requests to the app container on the correct port;

6. Run the containers and check if the SSL will be issued. With a bit luck, you won't have to deal with build or run errors.

1. Copy the database root credentials to the clipboard;

2. Edit the compose.yaml (or Dockerfile) to deploy a database management interface container, such as Adminer, phpMyAdmin, pgAdmin, RedisInsight etc;

3. Make sure the new container is linked to the database, the port is not being used and pass the secrets as env variables if possible or necessary;

4. Configure a virtual host or sub-directory on your reverse proxy to proxy the requests to the database management interface container;

5. Limit these interfaces to your specific IP address and guarantee you always access via HTTPS;

6. Access the interface and paste the database credentials if needed to login.

There isn't a straightforward way to manage the files inside a container, but there are a few options:

1. Use an IDE, such as Visual Studio with the Docker extension, and browse it through the sidebar. You won't be able to visualize the file metadata, such as ownership, permissions etc, but you will be able to access its content. To upload, compress and decompress files, you'll need to use the Terminal/SSH;

2. Use a SFTP client, such as FileZilla. That will allow you to list files with metadata, download, upload and modify files, but you won't be able to compress or decompress file;

3. Use a Terminal to connect to "/bin/bash" on the container - assuming it has Bash installed - and navigate via commands such as you would do in a SSH connection;

4. As long as you have a GUI on the host machine or VNC, mount a volume to the container (preferably before deploying) so you can manage the files used by the container on the host interface;

5. Deploy a container of a file manager application such as FileRun and create shared volumes between the containers so you can manage the files visually. Make sure you don't expose that application to the public, always access via HTTPS and use strong credentials.

Manage services inside the container depends on the state and composition of the container in question.

If you container is already running AND does have a process management such as Supervisord, Systemd, PM2 etc:

1. Use a Terminal to connect to "/bin/bash" on the container - assuming it has Bash installed;
2. Add any additional package repositories (such as yum or apt repos files) for the service and its dependencies if the packages are not available (or too outdated) at the standard repositories of the distro used by the container;
3. Reload the package manage repositories (such as apt/yum update);
4. Install the dependencies to run the service and/or the service itself;
5. Copy any necessary files to their respective locations (if any);
6. Adjust the service parameters on the configuration file (if any);
7. Add the necessary unit files to the process management software;
8. Reload the process management software;
9. Check if the service is running and adjust for any errors encountered.

If the container is already running AND does not have a process management, unfortunately you'll have to rebuild the container and copy all data out of the container.

If the container was not yet deployed AND it does not have a process management:

1. Create a custom Dockerfile with all the commands necessary to install the new service;
2. Add the commands to install your preferred process management software to the custom Dockerfile;
3. Create a unit file for each service you need to run on the container according to the process management software standard and use COPY instruction to copy the unit files to the correct location during the build;
4. Adjust the ENTRYPOINT of the Dockerfile so the container uses the process management software as it's main process;
5. Build the container and check if every service is running correctly afterwards.

1. Create a docker/podman network via CLI;

2. Edit your compose.yaml to include all the containers into the new network;

3. Replace your reverse proxy container with NGINX Proxy Manager or the alternative UI for your preferred reverse proxy on the compose.yaml file;

4. Restart the deployments;

5. Login into the admin UI and update the default login credentials;

6. Check the compose.yaml file to get the container names and ports so you can create a proxy, redirect, streams or 404 host.

There is not way to visually edit your cron jobs on containers. In fact, most containers won't have a cron daemon.

However, if your container does have a process management such as Supervisord, Systemd, PM2 etc:

1. Use a Terminal to connect to "/bin/bash" on the container - assuming it has Bash installed;
2. Install a text editor, such as vim, nano etc;
3. Install cronie, fcron or your preferred cron implementation;
4. Create a new unit file for the cron software on the process management directory;
5. Start the cron daemon via the process management;
6. Edit your crons with "crontab -e" command or the equivalent;
7. Save the cron file.