▶Book Description
Cloud computing and microservices are two very important concepts in modern software architecture. They represent key skills that ambitious software engineers need to acquire in order to design and build software applications capable of performing and scaling. Go is a modern cross-platform programming language that is very powerful yet simple; it is an excellent choice for microservices and cloud applications. Go is gaining more and more popularity, and becoming a very attractive skill..
The book will take you on a journey into the world of microservices and cloud computing with the help of Go. It will start by covering the software architectural patterns of cloud applications, as well as practical concepts regarding how to scale, distribute, and deploy those applications. You will also learn how to build a JavaScript-based front-end for your application, using TypeScript and React.
From there, we dive into commercial cloud offerings by covering AWS. Finally, we conclude our book by providing some overviews of other concepts and technologies that the reader can explore to move from where the book leaves off.
▶What You Will Learn
⦁ Understand modern software applications architectures
⦁ Build secure microservices that can effectively communicate with other services
⦁ Get to know about event-driven architectures by diving into message queues such as Kafka, Rabbitmq, and AWS SQS.
⦁ Understand key modern database technologies such as MongoDB, and Amazon's DynamoDB
⦁ Leverage the power of containers
⦁ Explore Amazon cloud services fundamentals
⦁ Know how to utilize the power of the Go language to access key services in the Amazon cloud such as S3, SQS, DynamoDB and more.
⦁ Build front-end applications using ReactJS with Go
⦁ Implement CD for modern applications
▶Key Features
⦁ Build well-designed and secure microservices. Enrich your microservices with continous integration and monitoring.
⦁ Containerize your application with Docker
⦁ Deploy your application to AWS. Learn how to utilize the powerful AWS services from within your application
▶Who This Book Is For
This book is for developers who want to begin building secure, resilient, robust, and scalable Go applications that are cloud native. Some knowledge of the Go programming language should be sufficient. To build the front-end application, you will also need some knowledge of JavaScript programming.
▶What this book covers
⦁ Chapter 1, Modern Microservice Architectures, opens the book by describing typical features of cloud-based applications and microservice architectures. We will also establish requirements and a high-level architecture for a fictional application that will serve as a continuous example over the following chapters of this book.
⦁ Chapter 2, Building Microservices Using REST APIs, discusses how to build modern microservices with the Go language. We will cover important and non-trivial topics. By the end of this chapter, you will have enough knowledge to build microservices that can expose RESTFul APIs, support persistence, and can effectively communicate with other services.
⦁ Chapter 3, Securing Microservices, shows you how to secure your microservices. You will get to learn about how to handle certificates and HTTPS in the Go language.
⦁ Chapter 4, Asynchronous Microservice Architectures, presents how to implement an asynchronous microservice architecture using message queues. For this, we will give an overview on established message queuing software, such as RabbitMQ and Apache Kafka, and present Go libraries to integrate these components into your software. We will also discuss architectural patterns such as Event Collaboration and Event Sourcing that work well together with asynchronous architectures.
⦁ Chapter 5, Building a Frontend with React, takes a small detour from the Go world into the JavaScript world and shows you how to build a web frontend for the microservice-based project using the React framework. For this, we will give a short overview over the basic architectural principles of React and how to build a React-based frontend for existing REST APIs.
⦁ Chapter 6, Deploying Your Application in Containers, shows how to deploy Go applications in a portable and reproducible way using application containers. You will learn to install and using Docker and how to build custom Docker images for your own Go applications. Furthermore, we will describe how to use the Kubernetes orchestration engine to deploy containerized applications in large-scale cloud environments.
⦁ Chapter 7, AWS –. Fundamentals, AWS SDK for Go and AWS EC2, is the first of two chapters to cover the AWS ecosystem. In this chapter, we will cover AWS in practical details. You will get exposed to several important concepts like how to setup AWS server instances, how to utilize the AWS API features, and how to write Go applications that are capable of interacting with AWS.
⦁ Chapter 8, AWS –. S3, SQS, API Gateway, and DynamoDB, continues to cover the AWS ecosystem in more detail. You will dive deeper into popular services in the AWS world. By the end of this chapter, you will have enough knowledge to build non-trivial Go cloud applications using the powers of Amazon Web Services.
⦁ Chapter 9, Continuous Delivery, describes how to implement a basic Continuous Delivery pipeline for your Go applications. For this, we will describe the basic principles of CD and how to implement a simple pipeline using tools such as Travis CI and Gitlab. We will use Docker images as deployment artifacts and deploy these images into a Kubernetes cluster, thus building on the topics and skills covered in Chapter 4, Asynchronous Microservice Architectures.
⦁ Chapter 10, Monitoring Your Application, shows you how to monitor your microservice architecture using Prometheus and Grafana. We will cover the basic architecture of Prometheus and describe how to set up a Prometheus instance using Docker. Also, you will learn how to adjust your Go applications to expose metrics that can be scraped by Prometheus. We will also describe how to set up a graphical user interface for Prometheus using Grafana.
⦁ Chapter 11, Migration, covers practical factors and approaches to consider when migrating from legacy monolithic applications into modern microservices cloud-ready applications.
⦁ Chapter 12, Where to Go from Here?, shows you where to continue the learning journey from here. It will cover other modern cloud-related technologies that deserve to be explored, such as alternative communication protocols, other cloud providers, and new architectural paradigms that might be the next big thing.
