To deploy a Dockerfile application on Coolify, create an Application in the correct project and environment, connect its source, choose Dockerfile as the build strategy, set the build context and Dockerfile path, expose the container’s listening port, add the domain and runtime configuration, then deploy and verify the resulting container. The most common causes of a deployment that appears healthy but is unreachable are an incorrect build context, a mismatched internal port, or a process bound to 127.0.0.1 instead of 0.0.0.0.
Antihost offers VPS plans with one-click Coolify, NVMe storage and a 14-day free trial.
What Coolify does with a Dockerfile application
Coolify coordinates the complete path from source to a running container. It queues a deployment, checks out the selected source when a repository is used, reads the Docker configuration, builds or pulls an image, applies environment variables and storage, creates the required network and port configuration, starts the container, evaluates health checks, and routes configured domains to healthy HTTP containers.
As an Amazon Associate I earn from qualifying purchases.
The Dockerfile controls the image itself: the base image, operating-system packages, files copied into the image, build stages, runtime user, and default command. Coolify applies deployment-time settings after the image is built. This separation matters: changing a Dockerfile normally requires a new image build, while changing a runtime variable or storage mount requires a new container or restart.
Coolify can run on your own server or through Coolify Cloud; in either case, the application workload runs on servers supplied by you. A Dockerfile-based application can come from a Git repository, a Dockerfile entered directly in Coolify, a Git-based Docker Compose definition, or an existing image. This guide concentrates on the Dockerfile application path.
#1 Best Overall
- [Ultra-Lightweight Ear Buds Designed for Small Ears] Each earbud weighs only 3.7g and features a compact, ergonomic in-ear design made especially for small ears. Secure, low-profile, and comfortable for workouts, all-day wear or overnight sleeping.The ultra-slim profile sits flush in your ear with no hard edges poking or rubbing, so you can even sleep on your side without discomfort.
- [Immersive Stereo Sound with TOZO OrigX Technology] TOZO OrigX tuning delivers clear vocals, balanced mids, and natural stereo sound for music, podcasts, and videos.
- [Long Battery Life for Daily Use] Get up to 7 hours of playtime on a single charge, with up to 32 hours total using the charging case—ideal for workdays, commuting, and extended listening sessions.
- [Bluetooth 5.3 & Stable Connection] Bluetooth 5.3 provides fast pairing, stable wireless performance, and reduced dropouts as you move around home or office.
- [Deep Bass with Clear Vocals] High-performance drivers produce punchy bass while keeping vocals clean and detailed for everyday listening.
Choose the right source and build path
Decide whether Coolify must read application files from a repository before creating the application. That decision determines the available build context and whether COPY and ADD instructions can work.
| Path | Use it when | Build-context consequence | Automation |
|---|---|---|---|
| Git repository with Dockerfile | Your image needs source code, package manifests, assets, scripts, or more than the Dockerfile itself. | Coolify checks out the repository. The selected Base Directory becomes Docker’s build context, so every file referenced by COPY or ADD must be inside it. |
Repository webhooks and automatic deployments can be used when configured. |
| Dockerfile without Git | The image can build from the Dockerfile and commands alone, without repository files. | There is no checked-out repository context. The Dockerfile cannot copy application files that exist elsewhere in a repository. | Deployments are manually triggered from the application or by an equivalent automation flow. |
| Existing image | Another process already builds and publishes the image and Coolify only needs to run it. | Coolify does not build from your Dockerfile in this path. | Image update and redeploy behavior depends on how the image is published and triggered. |
Use the Git path for almost every conventional web application. The no-Git path is appropriate for a self-contained image definition, a minimal service that installs everything during the build, or a test image. It is not a shortcut for uploading a Dockerfile while still expecting Coolify to find source files that were never provided.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Prepare the application before opening Coolify
Confirm the Dockerfile’s build assumptions
List every file used by COPY and ADD. Those paths are resolved from the build context, not from the directory containing the Dockerfile unless those directories happen to be the same. A monorepo commonly needs a subdirectory as its Base Directory so that the required package files and source tree are inside the context.
Check the final image’s default command and runtime user. The process started by that command must remain in the foreground; if it exits immediately, the container stops even though the image build succeeded. If the application expects an operating-system utility for startup or health checks, install it in the image.
Identify the internal listening port
Find the port on which the application listens inside the container. This is the value you will enter in Coolify’s Ports Exposes field. It is not necessarily the port used by a browser on the public internet, and it is not a host-port mapping. The process must listen on 0.0.0.0; a listener on 127.0.0.1 accepts connections only from inside the container and cannot be reached by Coolify’s proxy.
Rank #2
- 【IP68 Waterproof Multifunctinal Smart Watch】Torjalph fitness activity tracker smart watch is IP68 waterproof technology ,you can wear it when swimming,handwashing,it's rain-proof which means that you perform multiple exercise modes outside without worrying about sweat or rain corroding your fitness smart watch,and this watch equipped with a 230 mAh large capacity battery magnetic charging ,and this sports activity tracker watch can be used 5-7 days If fully charged.
- 【Larger 1.83'' Full Screen Watch & Multi-dial Selection】1.83 inch full HD color touch screen smart watch for men / women provides excellent 240*284 resolution image quality ,This Bluetooth smart watch offers a better touch experience and remarkable immersion and ,more than 200 watch faces for you to choose from App"Da Fit ", you can change the dial style according to your mood to wear keeping the world on your wrist
- 【Accurate Activity Tracker Smart Watch 】sports watch activity tracker uses sweat and dust resistant breathable silicone strap, our Fitness Tracker Smart Watch for Android iOS Phones supports 12 sports modes,walking,running,bicycle,swimming,badminton,basketball,football,rope skipping. This bluetooth calls smart watch for men women is lightweight and stylish, bringing more convenient and relaxing sports experience while also providing more protection.
- 【Your 24 Hour Personal Daily Health Monitor】Fitness watch for women men full touch screen IP67 waterproof bluetooth smartwatch for Android iOS Phones with heart rate blood pressure monitor multifunction Andriod smart watch with steps counter sleep monitor sports fitness watch, monitoring blood oxygen saturation allows you to understand your physical condition in real time to track fitness progress ,to know your health status in time.
- 【More Functions Bluetooth Call Smart Watch】This fitness activity smart watch full screen for iPhone and Android phones includes a bunch of new features including:The bluetooth smart watch can hang up the phone, receive and display WhatsAPP /Text /Facebook /Twitter /Messenger reminder.Support sedentary reminder, alarm clock, stopwatch, timer,weather information,music control, remote camera control compatible with Android 5.0 and above or iOS 9.0 and above smartphones.
Separate build-time and runtime configuration
Decide which values are needed while the image is being built and which are needed only when the container runs. Runtime values belong in Coolify’s environment settings. Build arguments can be managed under Advanced > Build. A value required during the build should not automatically be treated as a runtime variable, and a runtime secret should not be copied into an image layer merely because a build step can access it.
Plan persistence and recovery
Identify directories that must survive container replacement, such as uploaded files or a local database. A Coolify volume or bind mount preserves data across normal container replacement, but it is not a backup. Deletion, disk failure, corruption, or loss of the server can still destroy it. Arrange independent backups and test restoration before treating the deployment as production-ready.
Create the Coolify application
- Open the target project and environment. In Coolify, select the project that should own the service and then its target environment. Keeping production and non-production environments separate prevents variables, domains, and storage from being attached to the wrong deployment.
- Create a new Application. Choose the application resource rather than a database or unrelated service type.
- Select the source. For a repository, choose the supported connection method: a public repository, a deploy key, or a supported Git App. Select the repository and branch or revision that contains the Dockerfile. If no repository is required, choose the Dockerfile-without-Git path.
- Choose the Dockerfile build option. During creation, the interface may call this the Build pack. In current terminology, the setting appears after creation as Build strategy under General > Build pipeline. Select Dockerfile rather than a language-specific automatic builder.
- Save the initial application configuration. Coolify creates the resource so that its detailed build, network, domain, variable, storage, and health settings can be edited.
Set Base Directory and Dockerfile Location correctly
For a Git-backed application, open the application’s general build settings and set two paths:
- Base Directory: the directory Coolify should use as Docker’s build context.
- Dockerfile Location: the Dockerfile path relative to that Base Directory.
Suppose a repository contains services/catalog/Dockerfile and the Dockerfile copies files from the catalog service. Setting the Base Directory to /services/catalog makes that directory the context; the Dockerfile location is then the path to the Dockerfile relative to that context, according to the path format shown by Coolify. If you instead use the repository root as context, files under the service directory remain available, but relative paths inside the Dockerfile and the location setting must match that choice.
When a build fails with a message that a file cannot be found, inspect this pair before changing the Dockerfile. A file outside the selected context cannot be copied even if it exists in the repository. Docker intentionally prevents COPY and ADD from reading outside the build context.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problemsRank #3
- [Low Noise High Fidelity] New bee guitar cord with 22AWG oxygen-free-copper center conductors provides enhanced signal transfer, the PVC insulation material and the high-density stranded copper double shield provide noise rejection for quiet operation
- [Ideal for Choice] New bee 1/4 straight and right angle metal connectors, ensures a secure connection in any instrument, pedal, or amp jack. L shape great fro on stage guitar stands
- [Wide Compatible] Suitable for mixer, power amplifier, microphone, effector, decoder, equalizer, electoronic organ, electric guitar, electric bass and other electronic equipments. Widely used in the installation of smart home, karaoke speaker, professional stage audio, etc
- [Easy Disassemble] Making incidental repairs quick and easy! Very nice, flexible cable
- [Dont Hesite to Order] 24 hours customer services and professional technology team are standing by
Configure the internal port and network reachability
Set Ports Exposes to the container port
In the application settings, enter the port on which the process listens inside the container in Ports Exposes. Coolify uses this information to route the configured domain through its proxy. The value must match the application’s actual listener, not merely an EXPOSE line in the Dockerfile. An EXPOSE instruction is useful metadata, but it does not change a process that is listening on another port.
Bind the process to all container interfaces
Configure the framework or server to bind to 0.0.0.0. Many development servers default to localhost for safety, which works for a local command but fails inside a container behind a proxy. Confirm the bind address in the application’s startup arguments or environment variable, then check the startup log for the actual address and port.
Avoid unnecessary host-port mappings
Coolify’s normal domain path routes traffic to the internal container port. Publishing a host port directly is a different design: it exposes a server port and bypasses the normal domain-based proxy path. It can also prevent ordinary rolling replacement because the old and new containers cannot bind the same host port simultaneously. Use a host mapping only when you have a specific requirement that the proxy path cannot satisfy.
Add the domain, variables, and storage
Attach the public domain
Add the domain that should route to this application in the application’s domain settings. Ensure the DNS record points to the server that runs the Coolify proxy. The domain is routed only after the container is considered healthy and the proxy can reach the configured internal port. A successful image build alone does not prove that public routing will work.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Add runtime environment variables
Enter runtime configuration in Coolify’s environment settings rather than hard-coding production values in the Dockerfile. This keeps the same image reusable across environments and prevents secrets from becoming part of image history or layers. After saving variable changes, deploy or restart as appropriate; saving a setting does not necessarily replace the currently running container immediately.
Rank #4
- Digital Family Calendar: BSIMB digital calendar wall touch screen puts an end to your chaotic life. Designed for busy families, the digital calendar keeps you organised and in step with your family. Assign different colours and tasks to each family member to make family scheduling easier and more intuitive.
- Easy Setup and Auto-Sync: Plug in, connect to WLAN and auto-syn your electric calendar in minutes. Digital wall calendar compatible with Google calendar, iCloud calendar, Outlook calendar, Cozi calendar and Yahoo calendar. Add events directly on the device or through the ecalendar app. Electronic calendar stays current whether you're at work or traveling—no manual updates needed.
- All-In-One Home Assistant: Smart calendar builds habits and encourage independence with personalised chores. Display daily meal plan to reduce the daily ‘What's for dinner?’ stress. To-do lists keep track of everything you want. Turning chores into valuable achievements with stars and rewards, making life easier and more enjoyable.
- Manage Anytime Anywhere: BSIMB electronic calendar for family stay connected with the powerful ecalendar app. Access and manage your digital wall calendar anytime, anywhere with free features like stars & rewards, photo screensaver, chore charts, meals plans, to-do lists etc. Electronic planner paid features like Magic Import tailor advanced tools for users with special needs.
- Stay in Touch with Loved Ones: Share photos or videos from your phone to electronic wall calendar with app, instantly update your life moment, and keep in touch with your family, especially those who are far away; you can also surprise your smart calendar digital wall by sending him a wish card; it's also great for keeping tech-illiterate elders in touch with the youngsters.
Handle build arguments and build secrets
Use Advanced > Build for build arguments that genuinely affect image creation. Do not place production credentials in ordinary Dockerfile instructions or image layers. When a sensitive value is required during a build, use Docker BuildKit secrets when available so the value is supplied to the build step without being committed to the resulting image. Keep in mind that a build secret and a runtime environment variable serve different phases and should be configured separately.
Mount persistent data
Add a volume or bind mount for data that must survive replacement. Verify the mount path matches the directory the application actually writes to, and check ownership and permissions for the runtime user defined by the image. Treat the mount as durable storage, not as a backup system: maintain an independent backup schedule and perform restoration tests.
Define a health check that reflects real readiness
You can define a Docker HEALTHCHECK in the image or configure a health check in Coolify. A typical HTTP check is CMD curl --fail http://localhost:3000/health || exit 1, but the path and port must match your application. The image must contain the command used by the check; an image without curl will report an unhealthy result even when the application itself is working.
Use a readiness endpoint that verifies the service can accept requests, not merely that a process exists. If the application depends on a database or another service, decide whether readiness should wait for that dependency. An unhealthy container will not receive normal domain traffic, so inspect the health status and container logs before debugging DNS.
Deploy and read the deployment log
- Save all settings. Confirm the source revision, build strategy, Base Directory, Dockerfile Location, exposed port, domain, variables, storage, and health check.
- Select Deploy. Coolify queues the deployment and begins the build or image operation.
- Follow the Docker build stages. Confirm that the intended Dockerfile is being used and that each required dependency, file copy, and build stage completes. A successful build means an image was created; it does not by itself confirm that the runtime command or network configuration is correct.
- Watch container startup. Check the application log for the expected command, bind address, listening port, migrations, and startup errors.
- Check health status. If a health check is configured, wait for it to pass. Investigate missing commands, incorrect paths, dependency failures, or a wrong port if it remains unhealthy.
- Test the domain. Request the configured hostname through the proxy. Confirm that the response comes from the new container and that TLS, redirects, and application-level routing behave as expected.
Why a deployment is running but the domain is unreachable
| Symptom | Likely cause | What to check |
|---|---|---|
| Build succeeds, but the container exits | The default command finishes, crashes, or cannot find a runtime file. | Application logs, the final Dockerfile stage, the working directory, executable permissions, and required runtime packages. |
| Container is running, proxy returns a connection error | Wrong Ports Exposes value or the process listens on another port. | Startup logs and the process listener inside the container; make the Coolify port match the actual internal listener. |
| Container is running, but proxy cannot connect at all | The process is bound to 127.0.0.1. |
Change the server bind address to 0.0.0.0 and redeploy or restart. |
| Health check is unhealthy | The endpoint, port, command, or utility is wrong, or the service is not ready. | Run the check inside the image, verify the command exists, and inspect application and health logs. |
| Domain resolves to the wrong place | DNS still points elsewhere or the domain is attached to another service. | Check the DNS record, the selected Coolify server, and the application’s domain configuration. |
COPY reports a missing file |
The file lies outside the selected build context. | Correct Base Directory and Dockerfile Location, or reorganize the repository so required files are inside the context. |
| New variable or mount has no effect | The setting was saved but the running container was not replaced. | Deploy or restart after changing variables, storage, health checks, ports, networks, or limits. |
| Rolling replacement fails after adding a host port | Both old and new containers need the same host port. | Remove the unnecessary host mapping and use internal-port routing through the proxy. |
Redeploy behavior: which changes require an action
Coolify does not treat every saved field as an immediate live edit. Environment variables, storage, health checks, ports, networks, and resource limits require a deploy or restart before the running container receives them. Dockerfile or source changes require a deployment that builds a new image or deliberately reuses an existing image according to the configured build behavior.
When troubleshooting, record the exact source revision and deployment time. This prevents a common mistake in which a corrected Dockerfile is committed but the application is still running an older image. After redeploying, check the new build log and startup timestamp rather than relying only on the resource’s general running state.
Free tools Windows power users keep installed
One-click scans. No signup required.
Use the CLI when deployment must be automated
The official CLI workflow follows the same model as the web interface but requires more identifiers up front. You need a verified CLI context and token, the project and server UUIDs, a target environment, the Git repository and branch, the Dockerfile build pack, and the exposed internal port.
- Create the application through the CLI with the project, server, environment, repository, branch, build pack, and exposed port.
- Configure the application’s variables using the CLI’s variable operation, keeping runtime values separate from build-time arguments and secrets.
- Trigger a deployment by application UUID or name.
- List deployments to identify the current run and its status.
- Retrieve deployment details when a build or startup step fails.
- Inspect application logs to confirm the process, bind address, port, health behavior, and startup dependencies.
Use the CLI for repeatable provisioning or external automation, but apply the same safeguards as in the interface: validate the build context, do not embed secrets in image layers, and verify the public domain only after the internal health and routing checks pass.
Production verification checklist
- The build log completes and shows the intended Dockerfile stages.
- The final image contains the runtime command, files, packages, and health-check utility it needs.
- The process listens on the configured internal port and binds to
0.0.0.0. - Required runtime variables are present without production secrets embedded in Dockerfile instructions or image layers.
- Build arguments are configured only for values needed during image creation, with BuildKit secrets used for sensitive build-time data when available.
- The configured health check succeeds, or the application has a documented reason not to use one.
- Coolify application logs show expected startup behavior without crash loops.
- The configured domain reaches the healthy container through the proxy.
- Persistent directories are mounted at the paths the application writes to.
- Important data has an independent backup and a tested restoration procedure.
- A redeploy has been performed after changes that affect the running container.
Practical decision framework
Choose Git when the image contains application code
If the Dockerfile copies source files, installs dependencies from repository manifests, runs a compile step, or uses scripts stored alongside the code, use a Git-backed application. The repository supplies the build context and gives you a natural path to webhook-driven deployments and auditable revisions.
Choose no-Git only for a self-contained Dockerfile
If the Dockerfile can produce a working image without copying files from a repository, the no-Git option is simpler. Confirm that every command, configuration file, and runtime artifact is created by the Dockerfile or supplied through Coolify settings. If the design later grows to require source files, move to a Git-backed application rather than trying to work around the missing context.
Prefer internal routing for ordinary web services
For an HTTP application with a domain, configure the internal container port and let Coolify’s proxy handle public routing. Direct host-port publication is a specialized choice that complicates replacement and bypasses normal domain routing.
Make health and recovery explicit
A health check, application log review, persistent-storage plan, and independent backup schedule turn a merely running container into an operable service. Treat each as a separate concern: health checks decide whether traffic should be sent, storage preserves data across normal replacement, and backups protect against events that replacement cannot fix.
What success looks like
A successful Coolify Dockerfile deployment has a reproducible source revision, a build context that contains every required file, a Dockerfile that creates a runnable image, runtime variables supplied outside the image, and a process listening on the configured internal port at 0.0.0.0. Coolify then starts the container, marks it healthy when its check passes, and sends the configured domain to that container through the proxy. If any one of those links is missing, use the logs and port, context, health, and DNS checks above to isolate the failing layer instead of rebuilding blindly.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
