舉報 
會員
Building Microservices with Go
最新章節：
Summary
YoushouldhaveaworkingknowledgeofprogramminginGo,includingwritingandcompilingbasicapplications.However,noknowledgeofRESTfularchitecture,microservices,orwebservicesisexpected.Ifyouarelookingtoapplytechniquestoyourownprojects,takingyourfirststepsintomicroservicearchitecture,thisbookisforyou.
- Summary 更新時間：2021-07-15 17:29:06
- Complete workflow
- Monitoring/alerting
- Smoke tests
- Deployment
- Integration tests
- Static code analysis
- Benchmarking
- Testing
- Build
- Continuous delivery workflow
- Example application
- Creating the infrastructure
- Output variables
- VPC module
- Terraform config entry point
- Providers
- Terraform
- What is immutable infrastructure?
- Options for container orchestration
- What is container orchestration?
- Overview
- Continuous delivery process
- Monitoring
- End-to-end tests
- Smoke tests
- Static code analysis
- Security scanning
- Infrastructure as code
- Automation of integration tests
- Automation of tests
- Artifact storage
- Reproducibility and consistency
- Aspects of continuous delivery
- The benefits of continuous delivery
- Manual deployment
- What is continuous delivery?
- Continuous Delivery
- Summary
- Google Cloud Pub/Sub
- AWS SNS/SQS
- NATS.io
- Kafka
- Software
- Context mapping
- Bounded contexts
- Ubiquitous language
- Tactical design
- Strategic design
- Anatomy of DDD
- Technical debt
- What is DDD?
- Domain-driven design
- Command Query Responsibility Segregation (CQRS)
- Push messaging
- Pull/queue messaging
- Types of asynchronous messages
- Asynchronous processing
- Synchronous processing
- Differences between synchronous and asynchronous processing
- Event-Driven Architecture
- Summary
- Logging
- Patching application code
- Software updates
- Patching containers
- Maintenance
- Asymmetric encryption with large messages
- Shared secrets
- Secure messages
- Format of a JWT
- JWTs
- Benchmarks
- bcrypt
- Adding a pepper
- Dictionary attacks
- Adding a little seasoning
- Password hashing
- Authentication and authorization
- Insecure direct object references
- Cross-site scripting (XSS) and cross-site request forgery (CRSF)
- Never storing session tokens in a URL
- OWASP
- Physical machine access
- Securing data at rest
- Generating X.509 certificates
- Generating private keys
- TLS
- Fuzzing
- Input validation
- Attack
- Scenario
- How an attacker could bypass the firewall
- Confused deputy
- Recovery
- Response
- Detection
- Prevention
- Application security
- ACK
- SSDP
- SYN flood
- CHARGEN
- NTP
- DNS
- UDP flood
- UDP fragment attack
- Types of DDoS attack
- DDoS protection
- API Gateway
- Web application firewall
- Layer 2 or 3 firewalls
- External security
- TLS/SSL
- X.509 digital certificates
- Digital signatures
- Public-key cryptography
- Symmetric-key encryption
- Encryption and signing
- Security
- Summary
- Recover
- Panic
- Panic and recover
- Exceptions
- Kibana
- Elasticsearch Logstash and Kibana (ELK)
- Distributed tracing with Correlation IDs
- Logging
- Grafana
- Self-hosted
- Software as a Service
- Storage and querying
- Naming conventions
- Types of data best represented by metrics
- Metrics
- Logging best practices
- Logging and Monitoring
- Summary
- A few lines about gRPC
- Extensibility
- Support
- Security
- Open source
- Quality
- Efficiency
- Language independence
- Patterns
- Format
- Maintainable
- Tooling
- Code generation
- Setup
- gRPC
- Summing up Kite
- Extensibility
- Support
- Security
- Open source
- Quality
- Efficiency
- Language independence
- Patterns
- Format
- Maintainable
- Tooling
- Code generation
- Setup
- Kite
- What we learned about Micro
- Extensibility
- Support
- Security
- Open source
- Quality
- Efficiency
- Ability to interface with other frameworks
- Language independence
- Patterns
- Format (REST/RPC)
- Maintainable
- Tooling (CI/CD cross platform)
- Code generation
- Setup
- Micro
- What makes a good microservice framework?
- Microservice Frameworks
- Summary
- Stale cache in times of database or downstream service failure
- Premature optimization
- Caching
- Load balancing
- Client-side service discovery
- Server-side service discovery
- Service discovery
- Throttling
- Health checks
- Circuit breaking
- Back off
- Timeouts
- Atomic transactions
- Idempotent transactions and message order
- Dead Letter Queue
- Handling Errors
- Event processing with at least once delivery
- Event processing
- Patterns
- Design for failure
- Common Patterns
- Summary
- Profiling
- Benchmarks
- Benchmarking and profiling
- Testing with Docker Compose
- Behavioral Driven Development
- Code coverage
- Dependency injection and mocking
- httptest.NewRecorder
- httptest.NewRequest
- Unit tests
- Outside-in development
- The testing pyramid
- Testing
- Summary
- Specifying a project name
- Specifying the location of a compose file
- Service startup
- Installing Docker Compose on Linux
- Docker Compose
- Running Daemons in containers
- Docker Ignore files
- Docker build context
- Building images from Dockerfiles
- Good practice for creating Dockerfiles
- CMD
- ENTRYPOINT
- COPY
- EXPOSE
- MAINTAINER
- FROM
- Building application code for Docker
- Writing Dockerfiles
- Connecting containers to a custom network
- Creating a bridge network
- Creating custom bridge networks
- Project Calico
- Weaveworks
- Custom network drivers
- Overlay network
- No network
- Host networking
- Bridge networking
- Docker networking
- Removing a container starting with an explicit name
- Docker ports
- Mounting volumes
- Union filesystem
- Docker volumes
- Running our first container
- Installing Docker
- Introducing Containers with Docker
- Introducing Docker
- Summary
- RPC based-based APIs
- RAML
- API Blueprint
- Swagger
- REST based-based APIs
- Documenting APIs
- Intervals
- Durations
- Dates
- Object type standardization
- Naming for RPC
- Versioning formats for RPC APIs
- Versioning formats for REST APIs
- Semantic versioning
- Versioning APIs
- Filtering
- JSON-RPC
- Protocol Buffers
- Thrift
- Gob
- RPC message frameworks
- RPC API design
- RPC APIs
- CORS
- JSONP
- Accessing APIs from JavaScript
- Returning errors
- Standard response headers
- Accept-Encoding - gzip deflate
- Accept - content type
- Date
- Authorization - string
- Standard request headers
- HTTP headers
- 503 Service Unavailable
- 500 Internal Server Error
- 5xx Server Error
- 408 Request Timeout
- 405 Method Not Allowed
- 404 Not Found
- 403 Forbidden
- 401 Unauthorized
- 400 Bad Request
- 4xx Client Error
- 304 Not Modified
- 301 Moved Permanently
- 3xx Redirection
- 204 No Content
- 201 Created
- 200 OK
- 2xx Success
- Response codes
- URI query design
- OPTIONS
- HEAD
- DELETE
- PATCH
- PUT
- POST
- GET
- HTTP verbs
- CRUD function names
- Store
- Controller
- Documents
- Collections
- URI path design for REST services
- URI format
- URIs
- RESTful APIs
- Designing a Great API
- Summary
- JSON-RPC over HTTP
- RPC over HTTP
- Simple RPC example
- RPC in the Go standard library
- Using contexts
- WithValue
- WithTimeout
- WithDeadline
- WithCancel
- Background
- Context
- Creating handlers
- Static file handler
- TimeoutHandler
- StripPrefix
- RedirectHandler
- NotFoundHandler
- FileServer
- Convenience handlers
- Paths
- Routing in net/http
- Unmarshalling JSON to Go structs
- Marshalling Go structs to JSON
- Reading and writing JSON
- Building a simple web server with net/http
- Introduction to Microservices
- Questions
- Piracy
- Errata
- 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 Reviewers
- About the Author
- Credits
- Building Microservices with Go
- Copyright
- Title Page
- cover
- cover
- Title Page
- Copyright
- Building Microservices with Go
- Credits
- About the Author
- About the Reviewers
- 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
- Errata
- Piracy
- Questions
- Introduction to Microservices
- Building a simple web server with net/http
- Reading and writing JSON
- Marshalling Go structs to JSON
- Unmarshalling JSON to Go structs
- Routing in net/http
- Paths
- Convenience handlers
- FileServer
- NotFoundHandler
- RedirectHandler
- StripPrefix
- TimeoutHandler
- Static file handler
- Creating handlers
- Context
- Background
- WithCancel
- WithDeadline
- WithTimeout
- WithValue
- Using contexts
- RPC in the Go standard library
- Simple RPC example
- RPC over HTTP
- JSON-RPC over HTTP
- Summary
- Designing a Great API
- RESTful APIs
- URIs
- URI format
- URI path design for REST services
- Collections
- Documents
- Controller
- Store
- CRUD function names
- HTTP verbs
- GET
- POST
- PUT
- PATCH
- DELETE
- HEAD
- OPTIONS
- URI query design
- Response codes
- 2xx Success
- 200 OK
- 201 Created
- 204 No Content
- 3xx Redirection
- 301 Moved Permanently
- 304 Not Modified
- 4xx Client Error
- 400 Bad Request
- 401 Unauthorized
- 403 Forbidden
- 404 Not Found
- 405 Method Not Allowed
- 408 Request Timeout
- 5xx Server Error
- 500 Internal Server Error
- 503 Service Unavailable
- HTTP headers
- Standard request headers
- Authorization - string
- Date
- Accept - content type
- Accept-Encoding - gzip deflate
- Standard response headers
- Returning errors
- Accessing APIs from JavaScript
- JSONP
- CORS
- RPC APIs
- RPC API design
- RPC message frameworks
- Gob
- Thrift
- Protocol Buffers
- JSON-RPC
- Filtering
- Versioning APIs
- Semantic versioning
- Versioning formats for REST APIs
- Versioning formats for RPC APIs
- Naming for RPC
- Object type standardization
- Dates
- Durations
- Intervals
- Documenting APIs
- REST based-based APIs
- Swagger
- API Blueprint
- RAML
- RPC based-based APIs
- Summary
- Introducing Docker
- Introducing Containers with Docker
- Installing Docker
- Running our first container
- Docker volumes
- Union filesystem
- Mounting volumes
- Docker ports
- Removing a container starting with an explicit name
- Docker networking
- Bridge networking
- Host networking
- No network
- Overlay network
- Custom network drivers
- Weaveworks
- Project Calico
- Creating custom bridge networks
- Creating a bridge network
- Connecting containers to a custom network
- Writing Dockerfiles
- Building application code for Docker
- FROM
- MAINTAINER
- EXPOSE
- COPY
- ENTRYPOINT
- CMD
- Good practice for creating Dockerfiles
- Building images from Dockerfiles
- Docker build context
- Docker Ignore files
- Running Daemons in containers
- Docker Compose
- Installing Docker Compose on Linux
- Service startup
- Specifying the location of a compose file
- Specifying a project name
- Summary
- Testing
- The testing pyramid
- Outside-in development
- Unit tests
- httptest.NewRequest
- httptest.NewRecorder
- Dependency injection and mocking
- Code coverage
- Behavioral Driven Development
- Testing with Docker Compose
- Benchmarking and profiling
- Benchmarks
- Profiling
- Summary
- Common Patterns
- Design for failure
- Patterns
- Event processing
- Event processing with at least once delivery
- Handling Errors
- Dead Letter Queue
- Idempotent transactions and message order
- Atomic transactions
- Timeouts
- Back off
- Circuit breaking
- Health checks
- Throttling
- Service discovery
- Server-side service discovery
- Client-side service discovery
- Load balancing
- Caching
- Premature optimization
- Stale cache in times of database or downstream service failure
- Summary
- Microservice Frameworks
- What makes a good microservice framework?
- Micro
- Setup
- Code generation
- Tooling (CI/CD cross platform)
- Maintainable
- Format (REST/RPC)
- Patterns
- Language independence
- Ability to interface with other frameworks
- Efficiency
- Quality
- Open source
- Security
- Support
- Extensibility
- What we learned about Micro
- Kite
- Setup
- Code generation
- Tooling
- Maintainable
- Format
- Patterns
- Language independence
- Efficiency
- Quality
- Open source
- Security
- Support
- Extensibility
- Summing up Kite
- gRPC
- Setup
- Code generation
- Tooling
- Maintainable
- Format
- Patterns
- Language independence
- Efficiency
- Quality
- Open source
- Security
- Support
- Extensibility
- A few lines about gRPC
- Summary
- Logging and Monitoring
- Logging best practices
- Metrics
- Types of data best represented by metrics
- Naming conventions
- Storage and querying
- Software as a Service
- Self-hosted
- Grafana
- Logging
- Distributed tracing with Correlation IDs
- Elasticsearch Logstash and Kibana (ELK)
- Kibana
- Exceptions
- Panic and recover
- Panic
- Recover
- Summary
- Security
- Encryption and signing
- Symmetric-key encryption
- Public-key cryptography
- Digital signatures
- X.509 digital certificates
- TLS/SSL
- External security
- Layer 2 or 3 firewalls
- Web application firewall
- API Gateway
- DDoS protection
- Types of DDoS attack
- UDP fragment attack
- UDP flood
- DNS
- NTP
- CHARGEN
- SYN flood
- SSDP
- ACK
- Application security
- Prevention
- Detection
- Response
- Recovery
- Confused deputy
- How an attacker could bypass the firewall
- Scenario
- Attack
- Input validation
- Fuzzing
- TLS
- Generating private keys
- Generating X.509 certificates
- Securing data at rest
- Physical machine access
- OWASP
- Never storing session tokens in a URL
- Cross-site scripting (XSS) and cross-site request forgery (CRSF)
- Insecure direct object references
- Authentication and authorization
- Password hashing
- Adding a little seasoning
- Dictionary attacks
- Adding a pepper
- bcrypt
- Benchmarks
- JWTs
- Format of a JWT
- Secure messages
- Shared secrets
- Asymmetric encryption with large messages
- Maintenance
- Patching containers
- Software updates
- Patching application code
- Logging
- Summary
- Event-Driven Architecture
- Differences between synchronous and asynchronous processing
- Synchronous processing
- Asynchronous processing
- Types of asynchronous messages
- Pull/queue messaging
- Push messaging
- Command Query Responsibility Segregation (CQRS)
- Domain-driven design
- What is DDD?
- Technical debt
- Anatomy of DDD
- Strategic design
- Tactical design
- Ubiquitous language
- Bounded contexts
- Context mapping
- Software
- Kafka
- NATS.io
- AWS SNS/SQS
- Google Cloud Pub/Sub
- Summary
- Continuous Delivery
- What is continuous delivery?
- Manual deployment
- The benefits of continuous delivery
- Aspects of continuous delivery
- Reproducibility and consistency
- Artifact storage
- Automation of tests
- Automation of integration tests
- Infrastructure as code
- Security scanning
- Static code analysis
- Smoke tests
- End-to-end tests
- Monitoring
- Continuous delivery process
- Overview
- What is container orchestration?
- Options for container orchestration
- What is immutable infrastructure?
- Terraform
- Providers
- Terraform config entry point
- VPC module
- Output variables
- Creating the infrastructure
- Example application
- Continuous delivery workflow
- Build
- Testing
- Benchmarking
- Static code analysis
- Integration tests
- Deployment
- Smoke tests
- Monitoring/alerting
- Complete workflow
- Summary 更新時間：2021-07-15 17:29:06
