Microservices in Swift: Where to Start for Beginners in 2024

Why Swift is Not Just About Mobile Development?

When you hear "Swift", the first association is iOS apps. But in recent years, Swift has been confidently moving to the server side. And this is not just hype: Apple is actively developing the ecosystem, and the community is creating powerful frameworks. If you already write in Swift for iOS and want to broaden your horizons — microservices in Swift will be your logical next step.

Why microservices? Because it's the modern standard for building a backend: small, independent services that are easy to scale and update. And Swift, with its performance, type safety, and concise syntax, is perfectly suited for this. In this article, we'll break down where to start creating microservices in Swift, write real code, and launch your first service.

What Do You Need to Know Before Starting?

For comfortable reading, you will need:

• Basic knowledge of Swift (variables, functions, structures)
• Understanding of HTTP and REST (at least at the "there is a request — there is a response" level)
• Installed brew (for macOS) or Docker (for Linux)

If something is missing — no problem, we'll figure it out along the way.

Choosing Your Tool: Vapor — The King of Server-Side Swift

In the market of server-side frameworks for Swift, there are two main players: Vapor and Kitura (from IBM). But Kitura, unfortunately, is almost frozen. Meanwhile, Vapor is actively developed, has a huge community and documentation. So our choice is Vapor.

Vapor gives you everything out of the box: routing, middleware, database work, WebSocket, asynchrony via async/await. Perfect for building a microservice architecture in Swift.

Installing Vapor Toolbox

Open your terminal and run:

brew install vapor

After installation, check:

vapor --help

If you see a list of commands — everything is fine, you can create your first project.

Creating Your First Microservice: Hello, World!

Our first microservice will be simple: it will accept a GET request and return JSON. But we'll do it right — with an architecture ready for expansion.

Step 1. Create the Project

vapor new HelloMicroservice --template=authcd HelloMicroservice

The --template=auth flag will add a basic structure with authentication. For a microservice, this is good practice — to build in security from the start.

Step 2. Project Structure

After creation, you will see this structure:

HelloMicroservice/├── Sources/│   ├── App/│   │   ├── Controllers/│   │   ├── Models/│   │   └── configure.swift│   └── Run/│       └── main.swift├── Tests/├── Dockerfile└── Package.swift

Pay attention to Dockerfile — this is a ready-made template for containerization. Microservices without Docker are like pizza without cheese.

Step 3. Write Your First Endpoint

Let's open Sources/App/Controllers/UserController.swift (if it doesn't exist, create it). Add a simple method:

import Vapor

struct HealthController: RouteCollection {    func boot(routes: RoutesBuilder) throws {        let health = routes.grouped("api", "health")        health.get(use: checkHealth)    }        @Sendable    func checkHealth(req: Request) async throws -> HTTPStatus {        return .ok    }}

This is a classic health-check — the foundation of any microservice. Now register it in configure.swift:

// at the end of the configure functiontry app.register(collection: HealthController())

Step 4. Run and Test

vapor run

Open your browser or terminal:

curl http://localhost:8080/api/health# Response: 200 OK

Congratulations! You've