Hands-On Server-Side Web Development with Swift

By : Angus Yeung

Hands-On Server-Side Web Development with Swift

By: Angus Yeung

Overview of this book

This book is about building professional web applications and web services using Swift 4.0 and leveraging two popular Swift web frameworks: Vapor 3.0 and Kitura 2.5. In the first part of this book, we’ll focus on the creation of basic web applications from Vapor and Kitura boilerplate projects. As the web apps start out simple, more useful techniques, such as unit test development, debugging, logging, and the build and release process, will be introduced to readers. In the second part, we’ll learn different aspects of web application development with server-side Swift, including setting up routes and controllers to process custom client requests, working with template engines such as Leaf and Stencil to create dynamic web content, beautifying the content with Bootstrap, managing user access with authentication framework, and leveraging the Object Relational Mapping (ORM) abstraction layer (Vapor’s Fluent and Kitura’s Kuery) to perform database operations. Finally, in the third part, we’ll develop web services in Swift and build our API Gateway, microservices and database backend in a three-tier architecture design. Readers will learn how to design RESTful APIs, work with asynchronous processes, and leverage container technology such as Docker in deploying microservices to cloud hosting services such as Vapor Cloud and IBM Cloud.

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

Free Chapter

Introducing Server-Side Swift

Introducing Swift

Surveying Swift server-side frameworks

Choosing the right framework

Summary

Getting Started with Vapor and Kitura

Installing Vapor and Kitura on Mac

Installing Vapor and Kitura on Ubuntu

Exploring Vapor Toolbox and the Kitura CLI

Exploring the Kitura CLI

Summary

Building Your First Web App

Creating an app using Vapor CLI

Reviewing source code in Vapor boilerplate

Adding more routes in Vapor

Creating an app using Kitura CLI

Reviewing source code in Kitura boilerplate

Adding more routes in Kitura

Summary

Debugging and Testing

Writing tests for server-side Swift projects

Debugging in a server-side Swift project

Summary

Setting Up Routes and Controllers

Adding custom routes in a Vapor project

Adding custom routes in a Kitura project

Summary

Working with Template Engines

Using the Leaf templating engine in Vapor

Templating with Stencil in a Kitura project

Summary

Bootstrapping Your Design

Getting started with the Bootstrap framework

Using Bootstrap for a Vapor application

Using Bootstrap for Kitura

Summary

Employing Storage Framework

Installing databases

Working with the Fluent Framework in Vapor

Working with the Database Abstraction Layer in Kitura

Summary

Adding Authentication

Introducing the authentication API for Vapor

Introducing authentication for Kitura

Summary

Understanding Technologies for Web Services

Serving clients with web services

Encapsulating business logic into microservices

Cloud deployment

Summary

Designing for API Gateway

Serving clients with the RESTful API

Designing the RESTful API

Implementing the endpoints and responses

Implementing API endpoints for Kitura

Summary

Deploying to the Cloud

Deploying Vapor web service to Vapor Cloud

Deploying the Kitura web service to IBM Cloud

Summary

Developing an iPhone Client

Developing an iOS App for a server-side Swift application

Adding content to TableViewController

Adding domain exceptions for App Transport Security

Adding a new entry to journal

Using the Delegate Pattern

Hooking up new functionalities for UI items

Finishing the CRUD operations

Summary

Developing Microservices

Leveraging Microservices in Backend Applications

Deploying a Containerized Application to a Cluster

Summary

Vapor Boilerplate Project

Reviewing Vapor-generated files

Configuring Swift Package Manager

Starting with an entry point

Instantiating an application object

Configuring before instantiating application

Adding initialization code after application instantiation

Registering the application's routes

Implementing endpoint logic in controllers

Using a data model

Kitura Boilerplate Project

Reviewing Kitura-generated files

Understanding generated sourcecode in Kitura

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Understanding Technologies for Web Services

In this chapter, we'll see the underlying technologies that empower Web Services. You'll learn about the server/client model based on HTTP/HTTPS in more detail, and get introduced to the Model-View-Controller design pattern you've found in most of the Swift web frameworks. For the architecture design of Web Services, it would be better to divide the design into a three-tier architecture consisting of a frontend API gateway, middle business logic, and backend database services. You'll learn how a typical frontend API gateway is designed, how to encapsulate a middle component with business logic into a standalone microservice, and how to design and work with a backend storage framework.

In this chapter, we will cover the following topics:

Understanding the three-tier architecture for Web Services
Getting a review of...

Hands-On Server-Side Web Development with Swift

By : Angus Yeung

Hands-On Server-Side Web Development with Swift

By: Angus Yeung

Overview of this book

Related Content you might be interested in

Current Title:

Hands-On Server-Side Web Development with Swift

Hands-On Full-Stack Development with Swift

Learning Bootstrap 4 by Building Projects

Bootstrap 4 Cookbook