Index
A
- A/B deployments
- about / A/B deployments
- advantages / A/B deployments
- abstract base classes / Abstract base classes
- access patterns, EAI
- about / Access patterns
- asynchronous access pattern / Asynchronous access patterns
- synchronous access pattern / Synchronous access patterns
- Apache OpenWhisk
- using / Technical requirements
- about / A quick introduction to Apache OpenWhisk
- features / A quick introduction to Apache OpenWhisk
- code, executing / Getting the code ready to run with OpenWhisk
- serverless application, deploying / Deploying to OpenWhisk
- application, executing / Understanding the execution of application Inside Openwhisk
- API gateways
- about / API gateways in microservices
- challenges / API gateways in microservices
- advantages / API gateways in microservices, Utilizing API gateways for the integration of microservices
- in serverless architecture / API gateways in the serverless architecture
- microservices, integrating / Utilizing API gateways for the integration of microservices
- characteristics / Utilizing API gateways for the integration of microservices
- application
- building, for testing / Building an application with testing in mind
- test-driven development (TDD) / Test-driven development
- security, improving / Improving your application's security
- application, for performance issues
- probing / Probing an application for performance issues
- performance benchmarks, writing / Writing performance benchmarks
- component-level performance analysis / Doing component-level performance analysis
- live performance data, collecting / Collecting live performance data
- application-wide cache control
- setting / Setting application-wide cache control
- application concurrency
- boosting / Boosting the application concurrency
- executing, behind reverse proxy / Running behind a reverse proxy
- application deployment
- features / Deploying enterprise applications
- application development
- serverless approach / The serverless approach to application development
- asynchronous communication
- in microservices / Asynchronous communication in microservices
- message queues / Message queues for microservices communication
- asynchronous programming
- with AsyncIO / Asynchronous programming with AsyncIO
- AsyncIO
- used, for asynchronous programming / Asynchronous programming with AsyncIO
- program, writing / Writing a simple Python AsyncIO program
- socket server, implementing / Implementing a simple socket server with AsyncIO
- advantages / Implementing a simple socket server with AsyncIO
- AsyncIO, terminology
- about / AsyncIO terminology
- event loop / Event loop
- co-routines / Co-routines
- tasks / Tasks
- attack vectors
- about / Taking a look at the attack vectors
- with native applications / Security issues with native applications
- with web applications / Security issues with web applications
B
- backend as a service (BaaS)
- about / Backend as a service
- advantages / Backend as a service
- blue/green deployments
- about / Blue/green deployments
- benefits / Blue/green deployments
- BugZot / Introducing BugZot – a RESTful bug tracker
C
- caching
- utilizing / Utilizing caching
- at database level / Caching at the database level
- at block level / Caching at the block level
- user level caching, using / Using user-level caching
- canary deployments / Canary deployments
- client-side caching
- utilizing / Utilizing client-side caching
- benefits / Utilizing client-side caching
- application-wide cache control, setting / Setting application-wide cache control
- request level cache control, setting / Setting request level cache control
- client-side service discovery / Client-side service discovery
- cloud
- about / The move toward the cloud
- advantages / The move toward the cloud
- cloud deployment
- type / The different types of cloud deployments
- private cloud / Private clouds
- public cloud / Public clouds
- hybrid cloud / Hybrid clouds
- component-level performance analysis
- executing / Doing component-level performance analysis
- slow operations, measuring with timeit / Measuring slow operations with timeit
- profiling, with cProfile / Profiling with cProfile
- memory usage, profiling with memory-profiler / Profiling for memory usage with memory_profiler
- composition / Composition
- concurrency
- need for / The need for concurrency
- in GUI applications / Concurrency in GUI applications
- in enterprise applications / Concurrency in enterprise applications
- problems, of accommodating / The problems of accommodating increased concurrency
- scaling up / The multiple options to scale up
- concurrent access
- deploying for / Deploying for concurrent access
- Gunicorn, setting up / Setting up Gunicorn
- Nginx, setting up as reverse proxy / Setting up Nginx as reverse proxy
- communication, establishing between Nginx and Gunicorn / Establishing communication between Nginx and Gunicorn
- concurrent programming
- with Python / Concurrent programming with Python
- with multithreading / Concurrency with multithreading
- Global Interpreter Lock (GIL) / The story of GIL
- with multiprocessing / Concurrency with multiprocessing
- cProfile
- for profiling / Profiling with cProfile
- credential theft / Security issues with web applications
- Cross-Site Request Forgery (CSRF) / Security issues with web applications
- Cross-Site Scripting Attack (XSS) / Security issues with web applications
D
- database
- about / Database and object relational mappers
- SQLAlchemy, setting up / Setting up SQLAlchemy
- database consistency
- maintaining / Maintaining database consistency
- transaction, utilizing / Utilizing transactions to maintain consistency
- database models
- developing / Developing database models
- migrating / Migrating the database models
- data loading
- optimizing / Optimizing data loading
- advantages / Optimizing data loading
- deadlocks
- Denial of Service (DoS) / Security issues with web applications
- deployment strategy
- selecting / Making a choice about the deployment strategy
- about / The different deployment strategies
- recreated deployments / Recreated deployments
- rolling deployments / Rolling deployments
- blue/green deployment / Blue/green deployments
- canary deployments / Canary deployments
- A/B deployments / A/B deployments
- shadow deployments / Shadow deployments
- design pattern
- about / Design patterns
- problem statement / Design patterns
- solution / Design patterns
- consequences / Design patterns
- choice, defining / Defining the choice of design patterns
- design pattern, classification
- creational patterns / Classification of design patterns
- structural patterns / Classification of design patterns
- behavioral patterns / Classification of design patterns
- development environment
- setting up / Setting up the development environment
- database, setting up / Setting up the database
- virtual environment, setting up / Setting up the virtual environment
- project, structuring / Structuring our project
- development phase
- starting / Entering the development phase
- Flask project, initializing / Initializing the Flask project
- configuration, creating / Creating the configuration
- database models, developing / Developing database models
- views, building / Building the views
- Distributed Denial of Service (DDoS) / Security issues with web applications
- distributed tracing
- about / Distributed tracing
- benefits / Benefits of distributed tracing
- Docker
- using / Technical requirements, Technical requirements
- reference / Technical requirements, Technical requirements
E
- eager loading
- versus lazy loading / Understanding lazy loading versus eager loading
- about / Eager loading
- encapsulation / Encapsulation
- end-to-end testing / End-to-end testing in microservices
- enterprise-grade application
- requirements, defining / Defining the requirements
- Enterprise Application Integration (EAI)
- need for / The need for EAI
- challenges / The need for EAI
- point-to-point integration / Point-to-point integration
- using / Moving towards EAI
- traditional approach / The traditional approach to EAI
- features / The traditional approach to EAI
- drawbacks / The traditional approach to EAI
- patterns / Patterns in EAI
- integration patterns / Integration patterns
- access patterns / Access patterns
- issues / Issues in EAI
- with microservices / Microservices and the changing EAI landscape
- considering, in microservices / Rethinking EAI in microservices
- enterprise applications
- concurrency / Concurrency in enterprise applications
- deploying / Deploying enterprise applications
- enterprise application security
- about / Enterprise application security
- importance / The importance of enterprise security
- challenges / Challenges in system security
- enterprise ecosystem
- with Python / Python in the enterprise ecosystem
- enterprise IT
- requirements / The requirements of enterprise IT
- Enterprise Service Bus (ESB)
- about / The introduction of the ESB
- features / The introduction of the ESB
- microservices, integrating / Integrating microservices using the ESB
- transformation / Transformation of the ESB
- drawbacks / Transformation of the ESB
F
- Factory pattern
- about / The Factory pattern
- implementing / The Factory pattern
- federation pattern / Federation pattern
- Flask project
- initializing / Initializing the Flask project
- functionality testing / Functionality testing in microservices
- functional tests
- writing, with pytest / Writing functional tests with pytest
- function as a service (FaaS)
- about / Function as a service
- restrictions, on state management / The restrictions on state management
- restrictions, on execution times / Restrictions on execution times
- functions, executing / Executing functions inside FaaS
G
- GitHub API
- serverless application, integrating / Integrating with the GitHub API
- Global Interpreter Lock (GIL)
- about / Concurrent programming with Python, The story of GIL
- avoiding / The story of GIL
- GUI applications
- concurrency / Concurrency in GUI applications
- Gunicorn
- setting up / Setting up Gunicorn
- communication, establishing with Nginx / Establishing communication between Nginx and Gunicorn
H
- horizontal scaling / The multiple options to scale up
- hybrid cloud
- about / Hybrid clouds
- benefits / Hybrid clouds
I
- indexes
- advantage / Taking advantage of indexes
- infrastructure
- selecting / Making a choice of infrastructure
- traditional infrastructure / The traditional infrastructure
- containerized approach, for application packaging / Containerized approach toward application packaging
- cloud / The move toward the cloud
- inheritance
- about / Inheritance
- multiple inheritance / Multiple inheritance in Python
- integration patterns, EAI
- about / Integration patterns
- mediation pattern / Mediation pattern
- federation pattern / Federation pattern
- integration testing
- about / Integration testing
- features / Integration testing
- in microservices / Integration testing in microservices
J
- Jaeger
- using / Technical requirements
- JavaScript
- bundling / Bundling JavaScript
L
- lazy loading
- versus eager loading / Understanding lazy loading versus eager loading
- about / Using relationships, Lazy loading
- live performance data
- collecting / Collecting live performance data
- performance metrics, logging / Logging performance metrics
- Load Balancer / Rolling deployments, Canary deployments
- local web storage
- using / Working with local web storage
M
- man-in-the-middle attacks / Security issues with web applications
- mediation pattern / Mediation pattern
- memory_profiler
- memory usage, profiling / Profiling for memory usage with memory_profiler
- message brokers
- functionalities / Transformation of the ESB
- message queues
- about / Message queues for microservices communication
- message / Message queues for microservices communication
- queue / Message queues for microservices communication
- producer / Message queues for microservices communication
- consumer / Message queues for microservices communication
- benefits / Message queues for microservices communication
- metaclasses / Metaclasses
- microservices
- need for / The shift toward microservices
- versus monolithic development model / Monolithic development model versus microservices
- advantages / Advantages of the microservices architecture
- development, guidelines / Guidelines for microservice development
- service-level agreements (SLAs) / Service-level agreements in microservices
- service discovery / Service discovery in microservices
- API gateways / API gateways in microservices
- asynchronous communication / Asynchronous communication in microservices
- testing / Testing in the microservices world
- requests, tracing / Tracing requests inside microservices
- with Enterprise Application Integration (EAI) / Microservices and the changing EAI landscape
- traditional EAI, challenges / Challenges of traditional EAI in microservices
- point to point integration / Point-to-point integration of microservices
- integrating, with ESB / Integrating microservices using the ESB
- integration, challenges / Integrating microservices using the ESB
- integrating, with API gateways / Utilizing API gateways for the integration of microservices
- Enterprise Application Integration (EAI), considering / Rethinking EAI in microservices
- microservices application
- building / Building your first microservices application
- user microservice / The user microservice
- to-do manager service / The to-do manager service
- mixin
- about / Method resolution order in multiple inheritance
- utilizing / Utilizing mixins
- Model-View-Controller (MVC) pattern
- about / The Model-View-Controller pattern
- controller / Controller
- model / Model
- view / View
- multiple inheritance
- about / Multiple inheritance in Python
- method resolution order / Method resolution order in multiple inheritance
- multiprocessing
- for concurrency / Concurrency with multiprocessing
- Python multiprocessing module / Python multiprocessing module
- multiprocessing module, Python
- about / Python multiprocessing module
- processes, synchronizing / Synchronizing processes
- multithreading
- concurrency, achieving / Concurrency with multithreading
- thread synchronization / Thread synchronization
- multithreading, pitfalls
- about / Common pitfalls with multithreading
- race conditions / Race conditions
- deadlocks / Deadlocks
N
- native applications
- security issues / Security issues with native applications
- Nginx
- setting up, as reverse proxy / Setting up Nginx as reverse proxy
- communication, establishing with Gunicorn / Establishing communication between Nginx and Gunicorn
O
- object-oriented programming (OOP)
- about / Object-oriented Python
- principles / The basic OOP principles
- encapsulation / Encapsulation
- composition / Composition
- inheritance / Inheritance
- abstract base classes / Abstract base classes
- metaclasses / Metaclasses
- object relational mapper (ORM)
- about / Database and object relational mappers
- advantages / Database and object relational mappers
- OpenTracing standard / The OpenTracing standard
- optimal database models
- building / Building optimal database models
- issues, with model definition / Issues with our model definition
- characteristics / Optimizing our models
- optimizing / Optimizing our models
- indexes, advantages / Taking advantage of indexes
- optimized frontend
- need for / The need for optimizing frontends
- components / Components of an optimized frontend
- issues / What causes frontend issues
- resources, optimizing / Optimizing resources
- CSS, fetching in parallel / Fetching CSS in parallel by avoiding CSS imports
- JavaScript, building / Bundling JavaScript
P
- performance benchmarks
- writing / Writing performance benchmarks, Writing our first benchmark
- API benchmark, writing / Writing an API benchmark
- performance bottlenecks
- about / Behind the scenes of performance bottlenecks
- causes of / Looking at the causes of performance bottlenecks
- avoiding / Avoiding performance bottlenecks
- point-to-point integration
- about / Point-to-point integration
- with microservices / Point-to-point integration of microservices
- private cloud
- about / Private clouds
- selecting / Private clouds
- advantages / Private clouds
- public cloud
- about / Public clouds
- advantages / Public clouds
- pytest
- unit tests, writing / Writing unit tests with pytest
- setting up / Let's set up pytest
- test, writing / Writing our first test with pytest
- functional tests, writing / Writing functional tests with pytest
- Python
- in enterprise environment / Where Python shines
- in enterprise ecosystem / Python in the enterprise ecosystem
- concurrent programming / Concurrent programming with Python
- Python, developments
- about / Recent developments in Python
- backward compatibility, dropping / Dropping backward compatibility
- Unicode / It's all Unicode
- type hinting / Support for type hinting
- Python unittest
- unit tests, writing / Writing unit tests with Python unittest
- features / Writing unit tests with Python unittest
R
- race conditions
- about / Race conditions
- avoiding / Race conditions
- recreated deployments
- about / Recreated deployments
- advantages / Recreated deployments
- Relational Database Management System (RDBMS) / Optimizing our models
- relationships
- using / Using relationships
- One to One Relationships / Using relationships
- One to Many Relationships / Using relationships
- Many to Many Relationships / Using relationships
- request level cache control
- setting / Setting request level cache control
- reverse proxy
- application, executing / Running behind a reverse proxy
- improved security / Improved security
- improved connection, handling / Improved connection handling
- resource, caching / Resource caching
- static resources, serving / Serving static resources
- rolling deployments
- about / Rolling deployments
- benefits / Rolling deployments
S
- scalability testing / Scalability testing
- scalable application
- building / Engineering the application for scalability
- concurrency, controlling / Controlling the concurrency
- thread pools, using for incoming connections / Using thread pools for handling incoming connections
- scaling, concurrency
- vertical scaling / The multiple options to scale up
- horizontal scaling / The multiple options to scale up
- security anti-patterns
- about / Security anti-patterns
- user input, not filtering / Not filtering user input
- sensitive data, storing unencrypted / Storing Sensitive Data Unencrypted
- bound-checking, ignoring / Ignoring bound-checking
- libraries, not updating / Not keeping the libraries updated
- full database privileges, granting to user / Giving full privileges of the database to a single user
- server-side service discovery / Server-side service discovery
- serverless application
- execution / Understanding the execution of a serverless application
- function, cold-starting / Cold-starting a function
- function, hot-starting / Hot-starting a function
- building / Building our first serverless application
- building, with Apache OpenWhisk / A quick introduction to Apache OpenWhisk
- development environment, setting up / Setting up the development environment
- configuration file, building / Building our configuration file
- integrating, with GitHub API / Integrating with the GitHub API
- code, executing in OpenWhisk / Getting the code ready to run with OpenWhisk
- deployment / Taking the final steps toward deployment
- deploying, to OpenWhisk / Deploying to OpenWhisk
- advantages / Advantages of going serverless
- serverless approach
- to application development / The serverless approach to application development
- Backend as a service (BaaS) / The serverless approach to application development
- Function as a service (FaaS) / The serverless approach to application development
- serverless architecture
- components / Components of serverless architecture
- backend as a service (BaaS) / Backend as a service
- function as a service (FaaS) / Function as a service
- API gateways / API gateways in the serverless architecture
- service-level agreements (SLAs)
- about / Guidelines for microservice development
- in microservices / Service-level agreements in microservices
- service discovery
- about / Service discovery in microservices
- service registry / Service registry inside microservices
- client-side service discovery / Client-side service discovery
- server-side service discovery / Server-side service discovery
- service oriented architecture (SOA) / The traditional approach to EAI
- session storage
- using / Working with session storage
- shadow deployments / Shadow deployments
- single responsibility principle (SRP) / Guidelines for microservice development
- Singleton pattern
- about / The Singleton pattern
- __call__ magic method / The __call__ magic method
- socket server
- implementing, with AsyncIO / Implementing a simple socket server with AsyncIO
- software requirements
- gathering / Gathering requirements before development
- user requirements, defining / Asking for the user requirements
- categorizing / Categorizing the requirements
- functional requirements / Categorizing the requirements
- nonfunctional requirements / Categorizing the requirements
- prioritizing / Prioritizing the requirements
- document, generating / Generating the software requirement specification document
- software requirement specification (SRS) / Generating the software requirement specification document
- SQLAlchemy
- setting up / Setting up SQLAlchemy
- SQL Injections / Security issues with web applications
- synchronous access pattern / Synchronous access patterns
T
- test-driven development (TDD) / Test-driven development
- testing
- importance / The importance of testing
- benefits / The importance of testing
- types / The different kinds of testing
- unit testing / Unit testing
- integration testing / Integration testing
- testing, microservices
- about / Testing in the microservices world
- unit testing / Unit testing in microservices
- functionality testing / Functionality testing in microservices
- integration testing / Integration testing in microservices
- end-to-end testing / End-to-end testing in microservices
- scalability testing / Scalability testing
- challenges / Challenges in microservices testing
- workarounds / Challenges in microservices testing
- thread pools
- incoming connections, handling / Using thread pools for handling incoming connections
- thread synchronization
- about / Thread synchronization
- re-entrant locks / Re-entrant locks
- condition variables / Condition variables
- timeit
- slow operations, measuring / Measuring slow operations with timeit
- to-do manager service
- about / The to-do manager service
- implementing / The to-do manager service
- tracing
- of requests / Tracing requests inside microservices
- OpenTracing standard / The OpenTracing standard
- implementing, in ToDo manager / Implementing tracing inside ToDo manager
- distributed tracing / Distributed tracing
- traditional infrastructure
- about / The traditional infrastructure
- issues / The traditional infrastructure
- transaction
- consistency, maintaining / Utilizing transactions to maintain consistency
- type hinting / Support for type hinting
U
- Unicode / It's all Unicode
- unit testing
- about / Unit testing
- features / Unit testing
- in microservices / Unit testing in microservices
- unit tests
- writing / Writing unit tests
- writing, with Python unittest / Writing unit tests with Python unittest
- writing, with pytest / Writing unit tests with pytest
- user level caching
- using / Using user-level caching
- user microservice
- about / The user microservice
- functionalities / The user microservice
- user database model / The user microservice
- token database model / The user microservice
- /auth/register API / The user microservice
- /auth/login API / The user microservice
- /auth/validate API / The user microservice
- implementing / The user microservice
- users
- workforce / Asking for the user requirements
- management / Asking for the user requirements
V
- vertical scaling / The multiple options to scale up
- views
- building / Building the views
- index view, developing / Developing the index view
- index view, getting to render / Getting the index view to render
- user registration view, building / Building the user registration view
W
- web storage
- utilizing / Utilizing web storage
- local web storage, using / Working with local web storage
- session storage, using / Working with session storage