esköre™

InsightsVPS Setup & Hardening16 min readNovember 15, 2026

Server Hardening Services in Canada: What a Properly Secured VPS Includes in 2026

Looking for server hardening services in Canada? This practical guide covers the VPS checklist, the Docker and CI/CD steps most guides skip, and the PIPEDA and Law 25 records to keep.

VPS Setup & Hardening at Eskore
Photo by Unsplash on Unsplash

If you are looking for server hardening services in Canada, you are probably about to put an application on a virtual server, or you have inherited one that nobody locked down. Whether your business is in Toronto, Thornhill, New York, Austin, Raleigh or Denver, the technical baseline is the same, but the legal obligations differ by jurisdiction, and we cover both here. This guide sets out a practical checklist, explains the steps most hardening guides skip, and describes what a fair quote should include. Compare providers on what the work covers, not on a headline price per box.

Why a fresh VPS is exposed within minutes

When a new server gets a public IP address, automated scanners find it. They sweep the internet constantly, looking for open ports, default services and weak logins. You do not need to be a target to be probed. Much of that scanning is indiscriminate.

Default settings make it worse. Many server images leave SSH listening on port 22 with password logins switched on, and some run services the application never uses. Owners often find the evidence on day one: failed login attempts from addresses they have never heard of.

A fresh server is not a secure server. It is a starting point, and the work of making it secure comes after.

What server hardening services in Canada cover

Hardening is a baseline plus ongoing maintenance. The baseline sets each layer of the server to a deliberate configuration. The maintenance keeps it that way as software updates, staff change and the application grows. A one-off pass goes stale as soon as the software or the team changes.

The layers, from the outside in, are:

  • Access: how people and deploy tools log in
  • Network: which ports accept traffic
  • Operating system: updates, brute-force protection and running services
  • Application edge: the web server and TLS configuration
  • Containers: how Docker exposes services
  • Pipelines: how code reaches the server and who can trigger it
  • Visibility: monitoring, alerting, backups and restore tests

Each layer should have a setting and a written reason for it. If nobody can explain why a port is open, it should not be.

The checklist below starts with the basics, then covers the steps most public guides leave out. For the full scope of our work, see VPS Setup & Hardening.

SSH access: key-only login and no password sign-in

A widely cited hardening checklist calls disabling SSH password sign-in the single most effective SSH hardening step. Replacing passwords with keys removes the easiest route into the server.

The steps are:

  1. Generate a key pair on your own machine, with a passphrase on the private key.
  2. Copy the public key to a named user on the server. Avoid shared accounts.
  3. Disable password logins and root login. A drop-in file under /etc/ssh/sshd_config.d/ keeps the change tidy:
PasswordAuthentication no
PermitRootLogin no
  1. Give the named user sudo rights only where needed, and keep a record of who has them.
  2. Before closing your current session, open a second session and confirm you can still log in.

Keep a console or rescue route from your hosting provider available before you touch SSH settings. A lockout caused by a configuration change is the most common self-inflicted problem.

A default-deny firewall with UFW

Block all inbound traffic by default, then open only the ports the application needs. For a typical web application that means SSH, HTTP and HTTPS: ports 22, 80 and 443.

On Ubuntu or Debian, the core commands look like this:

ufw default deny incoming
ufw default allow outgoing
ufw allow OpenSSH
ufw allow 80/tcp
ufw allow 443/tcp
ufw enable

Allow SSH before you enable the firewall, or you may cut off your own access. If SSH runs on a non-standard port, allow that port instead. Open ports are a common reason servers get probed, so every rule should match a service you can name.

Be careful with the status page. Docker can expose container ports in ways UFW does not show, and the Docker section below explains why. A status page with no rule for a port does not prove the port is closed.

Patching, automatic updates and brute-force protection

Unattended security updates handle the routine work. On Ubuntu and Debian this is usually the unattended-upgrades package, set to apply security updates from the distribution and nothing else.

Decide in advance what happens to each type of update:

  • Security patches from the distribution: apply automatically, with email alerts on failure.
  • Kernel updates: apply in a maintenance window, because they usually need a reboot.
  • Major version upgrades and application dependencies: test first, because these can break the application.

Someone should own the "reboot required" flag and the alert that goes with it. An update nobody reads is not much better than no update.

For brute-force protection, fail2ban watches logs and bans addresses that fail to log in repeatedly. Configure it for SSH at a minimum, and add the web server if you want. Add your office IP addresses to the ignore list, so a mistyped password from the office does not lock the whole team out.

Removing services you do not need

Every running service and installed package is a potential way in, and most were installed for reasons nobody remembers. Remove what the application does not use, and write down what remains.

Start with a list of enabled services and listening ports. For each one, ask what it is for, who owns it, and whether the application needs it. Remove legacy packages that came with the image. Keep a simple register with four columns: service, port, reason and owner. When someone asks why a port is open six months later, the answer is already written down.

The steps most guides skip: Nginx, TLS, Docker and CI/CD

Most public checklists stop at the operating system, SSH and the firewall. Those matter, but for a business running an application, most of the exposure sits higher up: in the web server, the containers and the deployment pipeline.

The stack in this section is Linux, Nginx, Docker, GitHub Actions, Let's Encrypt, UFW, Prometheus and Grafana. Each has its own hardening decisions, and the decisions interact. The sections below go into the details that matter most.

Nginx and TLS with Let's Encrypt

The web server should accept HTTPS only. Requests on port 80 should redirect to HTTPS, and nothing sensitive should be served over plain HTTP. If the site behind Nginx is still being built, our web development team can build it with the server configuration in mind.

Let's Encrypt issues certificates at no cost, but they are short-lived. The certificate authority sets the lifetime, and that has changed over time, so do not build your process around a number from an old article. Renewal has to be automatic and tested. Certbot packages usually install a renewal timer. Run certbot renew --dry-run after setup, and add an alert for expiry, so you hear about a failed renewal before your customers do.

Three further settings matter:

  • Hide the version: set server_tokens off; so Nginx does not advertise its version to every scanner.
  • Security headers: add HSTS and other standard headers after checking they do not break the application. Start HSTS with a short max-age, because browsers cache it and it is slow to undo.
  • TLS protocols and ciphers: allow TLS 1.2 and 1.3, and take the cipher configuration from Mozilla's current server-side guidelines rather than an old blog post. Recommendations change, so check them when you configure the server.

Why Docker ports bypass UFW

This is where many otherwise careful setups fail. When you publish a container port, Docker writes its own iptables rules. Traffic to that port is forwarded to the container, and it does not follow the input rules UFW manages in the way most people assume. A container started with -p 5432:5432 can be reachable from the internet even though ufw status shows no rule for port 5432. Docker's packet filtering documentation describes this behaviour.

Fix it by deciding which containers should be reachable at all:

  1. Bind published ports to loopback. Use -p 127.0.0.1:3000:3000 so only the server itself can reach the container, and let Nginx proxy public traffic to it. In Compose, the same binding goes in the ports entry. This is the simplest pattern for web applications.
  2. Use the DOCKER-USER chain for rules that must filter forwarded traffic. Docker's documentation covers how to add rules there. Those rules are not removed when containers restart, but they still need saving so they return after a reboot.
  3. Do not publish internal services. Databases and background workers should sit on a Docker network with no published port.
  4. Verify from outside. Scan the server from a different network, such as a phone hotspot, using nmap. Trust that scan over the firewall status page.

Editing UFW's own files to work around Docker is possible, but it is fragile, and an upgrade can undo it. Binding to loopback is usually the better path.

Keeping databases and admin tools off the public internet

Databases, admin tools and monitoring dashboards should not be reachable from the public internet. Common mistakes include Grafana left on a public port with its default login, and a database listening on all interfaces because a tutorial said so.

For a typical application server:

  • Bind PostgreSQL or MySQL to 127.0.0.1 or a private network address, and confirm it in the configuration file.
  • Keep Docker networks internal where containers only need to talk to each other.
  • Reach admin tools through an SSH tunnel, a VPN, or Nginx with authentication in front. Do not publish them directly.

A database exposed to the internet turns any weak password or unpatched bug into a direct route to customer data.

Deploy keys, secrets and CI/CD pipelines

Deployment is often where small businesses have the least control. A pipeline set up two years ago may still use a key with full rights, and people who have left may still be able to trigger a production deploy.

The practical controls are:

  • Scope the deploy key. Use a read-only GitHub deploy key per repository, and give the server's deploy user only the permissions it needs.
  • Keep secrets out of the repository. Store them in GitHub's encrypted secrets, and never commit .env files or credentials.
  • Limit what workflows can do. Set the permissions key in each workflow to the minimum it needs.
  • Require approval for production. Use environment protection rules so a production deploy needs a named approver.
  • Protect the main branch. Require reviews before code reaches it.
  • Review who can deploy. Check repository admins and manual deploy rights each quarter, and rotate keys when someone leaves.

Pinning third-party actions to a full commit SHA, rather than a mutable tag, also stops a changed upstream action from running in your pipeline without your knowledge.

Monitoring, backups and restore testing

Hardening only helps if you can see when something drifts, and if you can recover when something goes wrong.

For visibility, Prometheus collects metrics from the server, usually through node_exporter, and Grafana displays them. Set alerts for the things that cause outages: a disk nearly full, a stopped service, a certificate expiring within two weeks, a spike in failed SSH logins, and security updates waiting or a reboot required. Each alert needs a named owner and a channel someone reads.

For backups, take regular copies of the database, the application configuration, the Docker volumes and the Let's Encrypt directory. Daily is a sensible starting point. Store them encrypted and off the server. Then test the restore. Restore to a separate machine, time how long it takes, and record the result. A backup only counts once you have restored from it, and the restore test is the record that shows it.

What a fair quote for server hardening in Canada should include

Many providers publish a per-server price. Those prices often cover a single machine and a narrow scope, such as the operating system, SSH and the firewall. The figures may be accurate for what they describe, but they do not compare with a build that also covers Nginx, TLS, containers, a deployment pipeline and monitoring. You are comparing two different jobs.

Before you compare numbers, ask every provider for the same things:

  • Written scope that lists each layer covered and what is excluded, such as application code, third-party licences and ongoing support.
  • A fixed price for that scope. The price should follow from the written list, not replace it. For how fixed-price builds handle change requests, read Fixed Price Custom Software Development in 2026.
  • A launch date agreed before work starts.
  • A handover that describes what you will receive at the end.
  • Account ownership. Find out who holds the cloud account, DNS, the registrar and the code repository, and make sure that is you.

Eskore offers written scope, a fixed price and a launch date before work starts. We do not publish a generic per-server price, because the right figure depends on what the server runs and what it needs to do. If the server supports a larger application, our custom software development team scopes the two together.

Does a managed VPS plan include hardening?

Not automatically. A managed plan is about running the server: monitoring, backups and updates handled by the provider. Hardening is about how the server is configured and secured. They are different pieces of work, so a plan that includes one does not automatically include the other. Our managed VPS hosting is monitored and backed up daily, but read the written scope for SSH access, firewall rules, TLS and container configuration before you assume they are covered.

The steps in this guide apply to a Linux server whichever provider it runs on, including a DigitalOcean droplet. The region affects latency and where your data is stored, so choose one close to your users, and check the provider's current region list directly before you decide. If you are weighing a move to AWS, Azure or Google Cloud, our cloud setup and migration team architects those platforms for scale and cost.

Canadian compliance: what PIPEDA and Law 25 expect from server security

This section is general information, not legal advice. Speak to a privacy lawyer about your specific obligations, in Canada and in any US state where your customers live.

PIPEDA, the federal private-sector privacy law, has a safeguards principle. It requires security safeguards proportionate to how sensitive the personal information is. It does not prescribe particular tools, so the question is whether your controls fit the risk and whether you can show that they do. Quebec's Law 25 adds obligations for businesses handling personal information in that province. These include appointing a person responsible for privacy, keeping a register of confidentiality incidents, and carrying out a privacy impact assessment before personal information is communicated outside Quebec.

Two points are often misunderstood:

  • PIPEDA does not require Canadian hosting. It allows personal information to be transferred to other countries, provided the organisation remains accountable for it. Canadian hosting can be a sensible choice for other reasons, but PIPEDA does not require it.
  • Law 25's impact assessment applies to transfers outside Quebec. A server in the United States is not automatically a problem. The assessment does have to be done and recorded.

Privacy rules change. Check the current text of PIPEDA and Law 25, and any new federal legislation, on the Office of the Privacy Commissioner of Canada and Quebec government sites before you rely on a summary, including this one.

Evidence a regulator or auditor would expect

If a client, insurer or regulator asks how you protect personal information, clear records will do more for you than a long explanation. Keep these:

  • MFA coverage: a list of every admin account, including the cloud console, GitHub, DNS, the registrar and email, with MFA confirmed for each.
  • Encryption settings: the current TLS configuration, disk encryption where it applies, and encryption for backups.
  • Access reviews: a dated list of who holds SSH, sudo and repository admin rights, with leavers removed.
  • Patch records: dates of updates and reboots, and any exceptions, with reasons.
  • Backup restore test results: the date, the scope of the restore and how long it took.
  • Change log: every configuration change, what it was for and who approved it.

Records like these make a security review quicker and less stressful.

Breach records and notification

Under PIPEDA's Breach of Security Safeguards Regulations, organisations must keep a record of every breach of security safeguards involving personal information under their control. They must keep those records for at least 24 months after determining that the breach occurred. This applies even to breaches that fall below the reporting threshold. Where a breach creates a real risk of significant harm, it must be reported to the Office of the Privacy Commissioner, and affected individuals must be notified.

Quebec's Law 25 requires a register of confidentiality incidents. Where an incident presents a risk of serious injury, the business must notify the Commission d'accès à l'information and the people concerned, and the notice must be prompt. Some summaries give a fixed 72-hour deadline for Quebec. That figure is more familiar from the EU's GDPR, so check the current Quebec text with the CAI before you write a deadline into your incident plan. Penalty figures also vary between summaries, so we have left them out. Take them from Quebec government sources if you need them.

If your customers are in the United States, the rules sit at state level. Every state has its own breach notification law, with different triggers, deadlines and regulators. New York's SHIELD Act, for example, requires businesses to maintain reasonable safeguards for the private information of New York residents, not just to notify after a breach. Texas, Colorado and North Carolina, where Austin, Denver and Raleigh are, each have their own rules. Make a short table of which state laws apply to your customer data, and keep it with your incident plan.

DIY or hire a team: an honest comparison

A capable Linux administrator can do a basic baseline without outside help. SSH keys, a default-deny firewall and unattended security updates are well documented. The part people underestimate is the careful first pass: checking each change, confirming that the external scan matches what you expect, and testing a restore.

Time is hard to estimate from a checklist. One provider's 2026 guide puts a basic baseline at around 30 minutes and a careful first pass at three to six hours. Treat those as rough figures from a competitor, not a quote. A full stack with containers, a deployment pipeline, TLS, backups and monitoring takes longer, and the real figure depends on what already exists on the server.

DIY makes sense when:

  • one person can own the server for the long term
  • the application is simple and the data is low-sensitivity
  • someone has time to run reviews and keep records

The risks are predictable:

  • Missed steps. Docker port exposure is the usual example.
  • Lockouts. A firewall or SSH change made without a second session open can cut off access.
  • No owner. The person who built it leaves, and nobody knows what is running or why.
  • No record. Undocumented changes make the next change risky.

Hiring a team makes sense when the server holds customer or staff data, when you need evidence for a compliance review, or when nobody in-house can run operations. If the server is part of a larger build, our custom software development team can handle the application and the infrastructure together, which removes a handoff between two suppliers. If you are comparing partners rather than checklists, how to choose a custom software developer for your small business in Toronto sets out the questions worth asking.

What you should receive when a hardened server is handed over

A hardened server without documentation is hard to maintain and harder to hand on. At handover you should receive:

  • An architecture overview: what runs where, and how traffic reaches it.
  • A runbook: deployment, rollback, restarting services, renewing certificates and restoring from backup.
  • A change log: every configuration change, with the date and the reason.
  • An access register: who has what access, and how MFA is set up.
  • A port and service inventory: the reason each open port and running service exists.
  • The monitoring setup: the alerts, and who receives them.
  • The backup policy: and the result of the most recent restore test.
  • A privacy map: which rules apply to the data the server holds. For US customers, list the state breach and safeguard laws that apply, such as New York's SHIELD Act for New York residents, and have a lawyer confirm them.
  • A review cadence: a monthly patch review and a quarterly access review, with a named owner for each.

Ownership matters as much as documentation. At Eskore, clients own the code and the accounts. Your cloud account, GitHub organisation, DNS, registrar and server access sit in your name, and so does the source code. You can see examples of our work in our case studies.

Talk to Eskore about server hardening services in Canada

Our standard is simple: a server configured properly, documented and handed over in your name, whether you are launching a first application or cleaning up a server someone else set up years ago. We work from offices in Toronto, Thornhill, London and New York. For readers in New York, Austin, Raleigh and Denver, our New York office can talk through how these controls and the relevant state rules fit your business.

To get a written scope and a fixed price before any work starts, book a 30-minute scoping call. Bring what the application does and what data it handles, your current hosting provider and region, the operating system version, and a list of the accounts you hold for cloud, DNS, the registrar and the code repository. We will tell you what a properly secured server would include for your business.

Questions

Need help with this?

Talk to our vps setup & hardening team.