舉報 
會員
Cloud Native programming with Golang
Mina Andrawos Martin Helmich 著
更新時間：2021-07-02 20:04:19
開會員，本書免費讀 >
最新章節：
Summary
Thisbookisfordeveloperswhowanttobeginbuildingsecure,resilient,robust,andscalableGoapplicationsthatarecloudnative.SomeknowledgeoftheGoprogramminglanguageshouldbesufficient.Tobuildthefront-endapplication,youwillalsoneedsomeknowledgeofJavaScriptprogramming.
最新章節
- Summary
- Serverless architectures
- Running containers in the cloud
- OpenStack
- Google Cloud Platform
- Microsoft Azure
品牌：中圖公司
上架時間：2021-07-02 18:27:04
出版社：Packt Publishing
本書數字版權由中圖公司提供，并由其授權上海閱文信息技術有限公司制作發行
- Summary 更新時間：2021-07-02 20:04:19
- Serverless architectures
- Running containers in the cloud
- OpenStack
- Google Cloud Platform
- Microsoft Azure
- Other cloud providers
- Amazon Relational Database Service
- Autoscaling on AWS
- DynamoDB streams
- More on AWS
- GRPC
- Protocol buffers
- Microservices communications
- Where to Go from Here?
- Summary
- CQRS
- Events sourcing
- Event-driven architecture for data consistency
- Data consistency
- Bounded contexts in domain-driven designs
- A four-tier engagement platform
- Sacrificial architecture
- Microservices design patterns
- Glue code
- How do we break the code?
- Cutting a monolithic application to pieces
- Humans and technology
- Migrating from monolithic applications to microservices
- What are microservices?
- What is a monolithic application?
- Migration
- Summary
- Running Prometheus on Kubernetes
- Exporting custom metrics
- Configuring Prometheus scrape targets
- Using the Prometheus client in your Go application
- Exporting metrics
- Running Grafana on Docker
- Running Prometheus on Docker
- Creating an initial Prometheus configuration file
- Prometheus's basics
- Setting up Prometheus and Grafana
- Monitoring Your Application
- Summary
- Setting up GitLab CI
- Setting up GitLab
- Using GitLab
- Deploying to Kubernetes
- Using Travis CI
- Vendoring your dependencies
- Setting up version control
- Setting up your project
- Continuous Delivery
- Summary
- The Go language and DynamoDB
- Creating tables
- Secondary indexes
- Primary keys
- Attribute value data types
- DynamoDB components
- DynamoDB
- AWS API gateway
- Simple Queue Service (SQS)
- Configuring S3
- Simple Storage Service (S3)
- AWS II–S3 SQS API Gateway and DynamoDB
- Summary
- Security groups
- Accessing EC2 from Windows
- Accessing EC2 instances from a Linux or macOS machine
- Accessing EC2 instances
- Creating EC2 instances
- Elastic Compute Cloud (EC2)
- Handling Errors
- Waiters
- Pagination methods
- Shared configuration
- Native datatypes
- Service clients
- Sessions
- The fundamentals of the AWS SDK for Go
- Creating IAM Roles
- Creating IAM Users
- Configuring AWS SDK authentication
- Configuring the AWS region
- AWS SDK for Go
- AWS services
- AWS Elastic Beanstalk
- AWS tags
- AWS regions and zones
- AWS command-line interface (CLI)
- The AWS console
- AWS fundamentals
- AWS I – Fundamentals AWS SDK for Go and EC2
- Summary
- Configuring HTTP Ingress
- Deploying the MyEvents components
- Making images available to Kubernetes
- Creating the MongoDB containers
- Creating the RabbitMQ broker
- Deploying MyEvents to Kubernetes
- Persistent volumes
- Services
- Core concepts of Kubernetes
- Setting up a local Kubernetes with Minikube
- Introduction to Kubernetes
- Deploying your application to the cloud
- Publishing your images
- Deploying your application with Docker Compose
- Building containers for the frontend
- Using static compilation for smaller images
- Building containers for the backend services
- Building containers
- Working with volumes
- Networking containers
- Building your own images
- Running simple containers
- Introduction to Docker
- What are containers?
- Deploying Your Application in Containers
- Summary
- Implementing the booking process
- Adding routing and navigation
- Testing the event list
- Enabling CORS in the backend services
- Building the event list components
- Bringing your own client
- Implementing the event list
- Kick-starting the MyEvents frontend
- Basic React principles
- Initializing the React project
- Setting up Node.js and TypeScript
- Getting started with React
- Building a Frontend with React
- Summary
- Consuming messages from Kafka
- Publishing messages with Kafka
- Connecting to Kafka with Go
- Basic principles of Apache Kafka
- Kafka quickstart with Docker
- Implementing publish/subscribe and event sourcing with Apache Kafka
- Event sourcing
- Building the booking service
- Building an event subscriber
- Building an event emitter
- Publishing and subscribing to AMQP messages
- Connecting RabbitMQ with Go
- Advanced RabbitMQ setups
- RabbitMQ quickstart with Docker
- The Advanced Message Queueing Protocol
- Implementing publish/subscribe with RabbitMQ
- Event collaboration
- Introducing the booking service
- The publish/subscribe pattern
- Asynchronous Microservice Architectures Using Message Queues
- Summary
- Building an HTTPS server in Go
- generate_cert.go
- OpenSSL
- Obtaining a certificate
- Secure web services in Go
- Asymmetrical cryptography in HTTPS
- Asymmetric cryptography
- Symmetric-key algorithms in HTTPS
- Symmetric cryptography
- HTTPS
- Securing Microservices
- Summary
- Implementing our RESTful APIs handler functions
- MongoDB and the Go language
- MongoDB
- Persistence layer
- Implementing a Restful API
- Gorilla web toolkit
- RESTful Web APIs
- Microservices internals
- So what are microservices?
- The background
- Building Microservices Using Rest APIs
- Summary
- The MyEvents platform
- REST web services and asynchronous messaging
- Deploying microservices
- What are microservices?
- The twelve-factor app
- Cloud application architecture patterns
- Cloud service models
- Basic design goals
- Why Go?
- Modern Microservice Architectures
- Questions
- Piracy
- Errata
- Downloading the color images of this book
- Downloading the example code
- Customer support
- Reader feedback
- Conventions
- Who this book is for
- What you need for this book
- What this book covers
- Preface
- Customer Feedback
- Why subscribe?
- www.PacktPub.com
- About the Reviewer
- About the Authors
- Credits
- 版權信息
- 封面
- 封面
- 版權信息
- Credits
- About the Authors
- About the Reviewer
- www.PacktPub.com
- Why subscribe?
- Customer Feedback
- Preface
- What this book covers
- What you need for this book
- Who this book is for
- Conventions
- Reader feedback
- Customer support
- Downloading the example code
- Downloading the color images of this book
- Errata
- Piracy
- Questions
- Modern Microservice Architectures
- Why Go?
- Basic design goals
- Cloud service models
- Cloud application architecture patterns
- The twelve-factor app
- What are microservices?
- Deploying microservices
- REST web services and asynchronous messaging
- The MyEvents platform
- Summary
- Building Microservices Using Rest APIs
- The background
- So what are microservices?
- Microservices internals
- RESTful Web APIs
- Gorilla web toolkit
- Implementing a Restful API
- Persistence layer
- MongoDB
- MongoDB and the Go language
- Implementing our RESTful APIs handler functions
- Summary
- Securing Microservices
- HTTPS
- Symmetric cryptography
- Symmetric-key algorithms in HTTPS
- Asymmetric cryptography
- Asymmetrical cryptography in HTTPS
- Secure web services in Go
- Obtaining a certificate
- OpenSSL
- generate_cert.go
- Building an HTTPS server in Go
- Summary
- Asynchronous Microservice Architectures Using Message Queues
- The publish/subscribe pattern
- Introducing the booking service
- Event collaboration
- Implementing publish/subscribe with RabbitMQ
- The Advanced Message Queueing Protocol
- RabbitMQ quickstart with Docker
- Advanced RabbitMQ setups
- Connecting RabbitMQ with Go
- Publishing and subscribing to AMQP messages
- Building an event emitter
- Building an event subscriber
- Building the booking service
- Event sourcing
- Implementing publish/subscribe and event sourcing with Apache Kafka
- Kafka quickstart with Docker
- Basic principles of Apache Kafka
- Connecting to Kafka with Go
- Publishing messages with Kafka
- Consuming messages from Kafka
- Summary
- Building a Frontend with React
- Getting started with React
- Setting up Node.js and TypeScript
- Initializing the React project
- Basic React principles
- Kick-starting the MyEvents frontend
- Implementing the event list
- Bringing your own client
- Building the event list components
- Enabling CORS in the backend services
- Testing the event list
- Adding routing and navigation
- Implementing the booking process
- Summary
- Deploying Your Application in Containers
- What are containers?
- Introduction to Docker
- Running simple containers
- Building your own images
- Networking containers
- Working with volumes
- Building containers
- Building containers for the backend services
- Using static compilation for smaller images
- Building containers for the frontend
- Deploying your application with Docker Compose
- Publishing your images
- Deploying your application to the cloud
- Introduction to Kubernetes
- Setting up a local Kubernetes with Minikube
- Core concepts of Kubernetes
- Services
- Persistent volumes
- Deploying MyEvents to Kubernetes
- Creating the RabbitMQ broker
- Creating the MongoDB containers
- Making images available to Kubernetes
- Deploying the MyEvents components
- Configuring HTTP Ingress
- Summary
- AWS I – Fundamentals AWS SDK for Go and EC2
- AWS fundamentals
- The AWS console
- AWS command-line interface (CLI)
- AWS regions and zones
- AWS tags
- AWS Elastic Beanstalk
- AWS services
- AWS SDK for Go
- Configuring the AWS region
- Configuring AWS SDK authentication
- Creating IAM Users
- Creating IAM Roles
- The fundamentals of the AWS SDK for Go
- Sessions
- Service clients
- Native datatypes
- Shared configuration
- Pagination methods
- Waiters
- Handling Errors
- Elastic Compute Cloud (EC2)
- Creating EC2 instances
- Accessing EC2 instances
- Accessing EC2 instances from a Linux or macOS machine
- Accessing EC2 from Windows
- Security groups
- Summary
- AWS II–S3 SQS API Gateway and DynamoDB
- Simple Storage Service (S3)
- Configuring S3
- Simple Queue Service (SQS)
- AWS API gateway
- DynamoDB
- DynamoDB components
- Attribute value data types
- Primary keys
- Secondary indexes
- Creating tables
- The Go language and DynamoDB
- Summary
- Continuous Delivery
- Setting up your project
- Setting up version control
- Vendoring your dependencies
- Using Travis CI
- Deploying to Kubernetes
- Using GitLab
- Setting up GitLab
- Setting up GitLab CI
- Summary
- Monitoring Your Application
- Setting up Prometheus and Grafana
- Prometheus's basics
- Creating an initial Prometheus configuration file
- Running Prometheus on Docker
- Running Grafana on Docker
- Exporting metrics
- Using the Prometheus client in your Go application
- Configuring Prometheus scrape targets
- Exporting custom metrics
- Running Prometheus on Kubernetes
- Summary
- Migration
- What is a monolithic application?
- What are microservices?
- Migrating from monolithic applications to microservices
- Humans and technology
- Cutting a monolithic application to pieces
- How do we break the code?
- Glue code
- Microservices design patterns
- Sacrificial architecture
- A four-tier engagement platform
- Bounded contexts in domain-driven designs
- Data consistency
- Event-driven architecture for data consistency
- Events sourcing
- CQRS
- Summary
- Where to Go from Here?
- Microservices communications
- Protocol buffers
- GRPC
- More on AWS
- DynamoDB streams
- Autoscaling on AWS
- Amazon Relational Database Service
- Other cloud providers
- Microsoft Azure
- Google Cloud Platform
- OpenStack
- Running containers in the cloud
- Serverless architectures
- Summary 更新時間：2021-07-02 20:04:19
