Speaker: Marco Bonezzi, Senior Technical Services Engineer, MongoDB
Level: 300 (Advanced)
Track: Microservices
Microservices architectures are becoming more popular and we see a trend towards smaller units of deployment based on containers. While most microservices need databases, implementing MongoDB on containers adds additional complexity: databases are stateful applications where data is critical. MongoDB is a complex distributed system with its own high availability implementation where using containers can expose additional risks.
In this session we will explore how to successfully define our database infrastructure with MongoDB running on Docker containers, how to orchestrate MongoDB containers with Kubernetes in multiple environments, considerations and strategies for managing stateful MongoDB containers, and how to manage high availability and resiliency in a distributed system while running on a container technology such as Kubernetes.
What You Will Learn:
- What to consider and how to maintain stateful databases in containers.
- How to configure deployment files, build a MongoDB deployment, and orchestrate it with Kubernetes, including how to test it on a laptop and then deploy it to Cloud.
- How to handle high availability in this environment, including data and application availability as well the additional error conditions the cloud and microservices introduce.
This presentation is related to nosql database and nosql database types information. this presentationa also contains discussion about, how mongodb works and mongodb security and mongodb sharding information.
PostgreSQL Tutorial For Beginners | EdurekaEdureka!
YouTube Link: https://youtu.be/-VO7YjQeG6Y
** MYSQL DBA Certification Training https://www.edureka.co/mysql-dba **
This Edureka PPT on PostgreSQL Tutorial For Beginners (blog: http://bit.ly/33GN7jQ) will help you learn PostgreSQL in depth. You will also learn how to install PostgreSQL on windows. The following topics will be covered in this session:
What is DBMS
What is SQL?
What is PostgreSQL?
Features of PostgreSQL
Install PostgreSQL
SQL Command Categories
DDL Commands
ER Diagram
Entity & Attributes
Keys in Database
Constraints in Database
Normalization
DML Commands
Operators
Nested Queries
Set Operations
Special Operators
Aggregate Functions
Limit, Offset & Fetch
Joins
Views
Procedures
Triggers
DCL Commands
TCL Commands
Export/ Import Data
UUID Datatype
Follow us to never miss an update in the future.
YouTube: https://www.youtube.com/user/edurekaIN
Instagram: https://www.instagram.com/edureka_learning/
Facebook: https://www.facebook.com/edurekaIN/
Twitter: https://twitter.com/edurekain
LinkedIn: https://www.linkedin.com/company/edureka
Castbox: https://castbox.fm/networks/505?country=in
This presentation explains the major differences between SQL and NoSQL databases in terms of Scalability, Flexibility and Performance. It also talks about MongoDB which is a document-based NoSQL database and explains the database strutre for my mouse-human research classifier project.
This presentation is related to nosql database and nosql database types information. this presentationa also contains discussion about, how mongodb works and mongodb security and mongodb sharding information.
PostgreSQL Tutorial For Beginners | EdurekaEdureka!
YouTube Link: https://youtu.be/-VO7YjQeG6Y
** MYSQL DBA Certification Training https://www.edureka.co/mysql-dba **
This Edureka PPT on PostgreSQL Tutorial For Beginners (blog: http://bit.ly/33GN7jQ) will help you learn PostgreSQL in depth. You will also learn how to install PostgreSQL on windows. The following topics will be covered in this session:
What is DBMS
What is SQL?
What is PostgreSQL?
Features of PostgreSQL
Install PostgreSQL
SQL Command Categories
DDL Commands
ER Diagram
Entity & Attributes
Keys in Database
Constraints in Database
Normalization
DML Commands
Operators
Nested Queries
Set Operations
Special Operators
Aggregate Functions
Limit, Offset & Fetch
Joins
Views
Procedures
Triggers
DCL Commands
TCL Commands
Export/ Import Data
UUID Datatype
Follow us to never miss an update in the future.
YouTube: https://www.youtube.com/user/edurekaIN
Instagram: https://www.instagram.com/edureka_learning/
Facebook: https://www.facebook.com/edurekaIN/
Twitter: https://twitter.com/edurekain
LinkedIn: https://www.linkedin.com/company/edureka
Castbox: https://castbox.fm/networks/505?country=in
This presentation explains the major differences between SQL and NoSQL databases in terms of Scalability, Flexibility and Performance. It also talks about MongoDB which is a document-based NoSQL database and explains the database strutre for my mouse-human research classifier project.
Real Time Data Processing using Spark Streaming | Data Day Texas 2015Cloudera, Inc.
Speaker: Hari Shreedharan
Data Day Texas 2015
Apache Spark has emerged over the past year as the imminent successor to Hadoop MapReduce. Spark can process data in memory at very high speed, while still be able to spill to disk if required. Spark’s powerful, yet flexible API allows users to write complex applications very easily without worrying about the internal workings and how the data gets processed on the cluster.
Spark comes with an extremely powerful Streaming API to process data as it is ingested. Spark Streaming integrates with popular data ingest systems like Apache Flume, Apache Kafka, Amazon Kinesis etc. allowing users to process data as it comes in.
In this talk, Hari will discuss the basics of Spark Streaming, its API and its integration with Flume, Kafka and Kinesis. Hari will also discuss a real-world example of a Spark Streaming application, and how code can be shared between a Spark application and a Spark Streaming application. Each stage of the application execution will be presented, which can help understand practices while writing such an application. Hari will finally discuss how to write a custom application and a custom receiver to receive data from other systems.
What to Expect From Oracle database 19cMaria Colgan
The Oracle Database has recently switched to an annual release model. Oracle Database 19c is only the second release in this new model. So what can you expect from the latest version of the Oracle Database? This presentation explains how Oracle Database 19c is really 12.2.0.3 the terminal release of the 12.2 family and the new features you can find in this release.
Creating Highly Available MongoDB Microservices with Docker Containers and Ku...MongoDB
In this webinar recording we explored how to successfully define our database infrastructure with MongoDB running on Docker containers, how to orchestrate MongoDB containers with Kubernetes in multiple environments, considerations and strategies for managing stateful MongoDB containers, and how to manage high availability and resiliency in a distributed system while running on a container technology such as Kubernetes.
Powering Microservices with MongoDB, Docker, Kubernetes & Kafka – MongoDB Eur...Andrew Morgan
Organisations are building their applications around microservice architectures because of the flexibility, speed of delivery, and maintainability they deliver.
Want to try out MongoDB on your laptop? Execute a single command and you have a lightweight, self-contained sandbox; another command removes all trace when you're done. Need an identical copy of your application stack in multiple environments? Build your own container image and then your entire development, test, operations, and support teams can launch an identical clone environment.
Containers are revolutionizing the entire software lifecycle: from the earliest technical experiments and proofs of concept through development, test, deployment, and support. Orchestration tools manage how multiple containers are created, upgraded and made highly available. Orchestration also controls how containers are connected to build sophisticated applications from multiple, microservice containers.
This presentation introduces you to technologies such as Docker, Kubernetes & Kafka which are driving the microservices revolution. Learn about containers and orchestration – and most importantly how to exploit them for stateful services such as MongoDB.
Real Time Data Processing using Spark Streaming | Data Day Texas 2015Cloudera, Inc.
Speaker: Hari Shreedharan
Data Day Texas 2015
Apache Spark has emerged over the past year as the imminent successor to Hadoop MapReduce. Spark can process data in memory at very high speed, while still be able to spill to disk if required. Spark’s powerful, yet flexible API allows users to write complex applications very easily without worrying about the internal workings and how the data gets processed on the cluster.
Spark comes with an extremely powerful Streaming API to process data as it is ingested. Spark Streaming integrates with popular data ingest systems like Apache Flume, Apache Kafka, Amazon Kinesis etc. allowing users to process data as it comes in.
In this talk, Hari will discuss the basics of Spark Streaming, its API and its integration with Flume, Kafka and Kinesis. Hari will also discuss a real-world example of a Spark Streaming application, and how code can be shared between a Spark application and a Spark Streaming application. Each stage of the application execution will be presented, which can help understand practices while writing such an application. Hari will finally discuss how to write a custom application and a custom receiver to receive data from other systems.
What to Expect From Oracle database 19cMaria Colgan
The Oracle Database has recently switched to an annual release model. Oracle Database 19c is only the second release in this new model. So what can you expect from the latest version of the Oracle Database? This presentation explains how Oracle Database 19c is really 12.2.0.3 the terminal release of the 12.2 family and the new features you can find in this release.
Creating Highly Available MongoDB Microservices with Docker Containers and Ku...MongoDB
In this webinar recording we explored how to successfully define our database infrastructure with MongoDB running on Docker containers, how to orchestrate MongoDB containers with Kubernetes in multiple environments, considerations and strategies for managing stateful MongoDB containers, and how to manage high availability and resiliency in a distributed system while running on a container technology such as Kubernetes.
Powering Microservices with MongoDB, Docker, Kubernetes & Kafka – MongoDB Eur...Andrew Morgan
Organisations are building their applications around microservice architectures because of the flexibility, speed of delivery, and maintainability they deliver.
Want to try out MongoDB on your laptop? Execute a single command and you have a lightweight, self-contained sandbox; another command removes all trace when you're done. Need an identical copy of your application stack in multiple environments? Build your own container image and then your entire development, test, operations, and support teams can launch an identical clone environment.
Containers are revolutionizing the entire software lifecycle: from the earliest technical experiments and proofs of concept through development, test, deployment, and support. Orchestration tools manage how multiple containers are created, upgraded and made highly available. Orchestration also controls how containers are connected to build sophisticated applications from multiple, microservice containers.
This presentation introduces you to technologies such as Docker, Kubernetes & Kafka which are driving the microservices revolution. Learn about containers and orchestration – and most importantly how to exploit them for stateful services such as MongoDB.
MongoDB Europe 2016 - Powering Microservices with Docker, Kubernetes, and KafkaMongoDB
Organisations are building their applications around microservice architectures because of the flexibility, speed of delivery, and maintainability they deliver. This session introduces you to technologies such as Docker, Kubernetes & Kafka which are driving the microservices revolution. Learn about containers and orchestration – and most importantly how to exploit them for stateful services such as MongoDB.
Powering Microservices with Docker, Kubernetes, Kafka, and MongoDBMongoDB
Speaker: Andrew Morgan, Principal Product Marketing Manager, MongoDB
Level: 100 (Beginner)
Track: Microservices
Organizations are building their applications around microservice architectures because of the flexibility, speed of delivery, and maintainability they deliver. Want to try out MongoDB on your laptop? Execute a single command and you have a lightweight, self-contained sandbox; another command removes all trace when you're done. Replicate your complete application for your development, test, operations, and support teams. This session introduces you to technologies such as Docker, Kubernetes, and Kafka, which are driving the microservices revolution. Learn about containers and orchestration – and most importantly, how to exploit them for stateful services such as MongoDB.
What You Will Learn:
- Why organizations are choosing to use microservice architectures, what benefits they deliver, and when they should - or shouldn't - be used.
- Technologies that are used to build microservices – including containers, orchestration and messaging systems.
- Why MongoDB is a good fit for microservices and what special steps need to be taken to make them work well together.
Webinar: Enabling Microservices with Containers, Orchestration, and MongoDBMongoDB
Want to try out MongoDB on your laptop? Execute a single command and you have a lightweight, self-contained sandbox; another command removes all trace when you're done. Need an identical copy of your application stack in multiple environments? Build your own container image and then your entire development, test, operations, and support teams can launch an identical clone environment.
Containers are revolutionizing the entire software lifecycle: from the earliest technical experiments and proofs of concept through development, test, deployment, and support. Orchestration tools manage how multiple containers are created, upgraded and made highly available. Orchestration also controls how containers are connected to build sophisticated applications from multiple, microservice containers.
This webinar introduces the concepts behind containers and orchestration, then explains the available technologies and how to use them with MongoDB. Finally, you will see a demonstration of exactly how to create a MongoDB replica set on Docker and Kubernetes within the Google Cloud.
MongoDB Ops Manager is an enterprise-grade end-to-end database management, monitoring, and backup solution. Kubernetes has clearly won the orchestration-platform "wars". In this session we'll take a deep dive on how you can leverage both these technologies to host your MongoDB deployments within your Kubernetes infrastructure whether that's OpenShift, PKS, Azure AKS, or just upstream. This talk will review the core technologies, such as containers, Kubernetes, and MongoDB Ops Manager. You'll also have a chance to see real-live demos of MongoDB running on Kubernetes and managed with MongoDB Ops Manager with the MongoDB Enterprise Kubernetes Operator.
Powering Microservices with Docker, Kubernetes, Kafka, & MongoDBMongoDB
This session introduced technologies such as Docker, Kubernetes, and Kafka, which are driving the microservices revolution. Learn about containers and orchestration – and most importantly, how to exploit them for stateful services such as MongoDB.
What You Will Learn:
* Why organizations are choosing to use microservice architectures, what benefits they deliver, and when they should – or shouldn't – be used.
* Technologies that are used to build microservices – including containers, orchestration, and messaging systems.
* Why MongoDB is a good fit for microservices and what special steps need to be taken to make them work well together.
MongoDB SoCal 2020: Using MongoDB Services in Kubernetes: Any Platform, Devel...MongoDB
MongoDB Kubernetes operator and MongoDB Open Service Broker are ready for production operations. Learn about how MongoDB can be used with the most popular container orchestration platform, Kubernetes, and bring self-service, persistent storage to your containerized applications. A demo will show you how easy it is to enable MongoDB clusters as an External Service using the Open Service Broker API for MongoDB
The rise of microservices - containers and orchestrationAndrew Morgan
Organisations are building their applications around microservice architectures because of the flexibility, speed of delivery, and maintainability they deliver. In this session, the concepts behind containers and orchestration will be explained and how to use them with MongoDB.
O Azure Cosmos DB trás poderosas e versateis APIs com suporte a engines como SQL, MongoDB, Cassandra, Graph e Table. Globalmente distribuído em mais de 30 regiões é uma otima opção na nuvem, fácil de escalar com alta disponilidade, alto throughput e baixíssima latencia. TDC2018, The Developer Conference Florianopolis 2018
Powering Microservices with Docker, Kubernetes, Kafka, and MongoDBMongoDB
Speaker: Andrew Morgan
Organizations are building their applications around microservice architectures because of the flexibility, speed of delivery, and maintainability they deliver. Want to try out MongoDB on your laptop? Execute a single command and you have a lightweight, self-contained sandbox; another command removes all trace when you're done. Replicate your complete application for your development, test, operations, and support teams. This session introduces you to technologies such as Docker, Kubernetes, and Kafka, which are driving the microservices revolution. Learn about containers and orchestration, and most importantly, how to exploit them for stateful services such as MongoDB.
Slides from workshop held on 12/14 in Asbury Park, NJ
http://www.meetup.com/Jersey-Shore-Tech/events/148118762/?gj=ro2_e&a=ro2_gnl&rv=ro2_e&_af_eid=148118762&_af=event
MongoDB SoCal 2020: Migrate Anything* to MongoDB AtlasMongoDB
During this talk we'll navigate through a customer's journey as they migrate an existing MongoDB deployment to MongoDB Atlas. While the migration itself can be as simple as a few clicks, the prep/post effort requires due diligence to ensure a smooth transfer. We'll cover these steps in detail and provide best practices. In addition, we’ll provide an overview of what to consider when migrating other cloud data stores, traditional databases and MongoDB imitations to MongoDB Atlas.
MongoDB SoCal 2020: Go on a Data Safari with MongoDB Charts!MongoDB
These days, everyone is expected to be a data analyst. But with so much data available, how can you make sense of it and be sure you're making the best decisions? One great approach is to use data visualizations. In this session, we take a complex dataset and show how the breadth of capabilities in MongoDB Charts can help you turn bits and bytes into insights.
MongoDB SoCal 2020: A Complete Methodology of Data Modeling for MongoDBMongoDB
Are you new to schema design for MongoDB, or are you looking for a more complete or agile process than what you are following currently? In this talk, we will guide you through the phases of a flexible methodology that you can apply to projects ranging from small to large with very demanding requirements.
MongoDB SoCal 2020: From Pharmacist to Analyst: Leveraging MongoDB for Real-T...MongoDB
Humana, like many companies, is tackling the challenge of creating real-time insights from data that is diverse and rapidly changing. This is our journey of how we used MongoDB to combined traditional batch approaches with streaming technologies to provide continues alerting capabilities from real-time data streams.
MongoDB SoCal 2020: Best Practices for Working with IoT and Time-series DataMongoDB
Time series data is increasingly at the heart of modern applications - think IoT, stock trading, clickstreams, social media, and more. With the move from batch to real time systems, the efficient capture and analysis of time series data can enable organizations to better detect and respond to events ahead of their competitors or to improve operational efficiency to reduce cost and risk. Working with time series data is often different from regular application data, and there are best practices you should observe.
This talk covers:
Common components of an IoT solution
The challenges involved with managing time-series data in IoT applications
Different schema designs, and how these affect memory and disk utilization – two critical factors in application performance.
How to query, analyze and present IoT time-series data using MongoDB Compass and MongoDB Charts
At the end of the session, you will have a better understanding of key best practices in managing IoT time-series data with MongoDB.
Join this talk and test session with a MongoDB Developer Advocate where you'll go over the setup, configuration, and deployment of an Atlas environment. Create a service that you can take back in a production-ready state and prepare to unleash your inner genius.
MongoDB .local San Francisco 2020: Powering the new age data demands [Infosys]MongoDB
Our clients have unique use cases and data patterns that mandate the choice of a particular strategy. To implement these strategies, it is mandatory that we unlearn a lot of relational concepts while designing and rapidly developing efficient applications on NoSQL. In this session, we will talk about some of our client use cases, the strategies we have adopted, and the features of MongoDB that assisted in implementing these strategies.
MongoDB .local San Francisco 2020: Using Client Side Encryption in MongoDB 4.2MongoDB
Encryption is not a new concept to MongoDB. Encryption may occur in-transit (with TLS) and at-rest (with the encrypted storage engine). But MongoDB 4.2 introduces support for Client Side Encryption, ensuring the most sensitive data is encrypted before ever leaving the client application. Even full access to your MongoDB servers is not enough to decrypt this data. And better yet, Client Side Encryption can be enabled at the "flick of a switch".
This session covers using Client Side Encryption in your applications. This includes the necessary setup, how to encrypt data without sacrificing queryability, and what trade-offs to expect.
MongoDB .local San Francisco 2020: Using MongoDB Services in Kubernetes: any ...MongoDB
MongoDB Kubernetes operator is ready for prime-time. Learn about how MongoDB can be used with most popular orchestration platform, Kubernetes, and bring self-service, persistent storage to your containerized applications.
MongoDB .local San Francisco 2020: Go on a Data Safari with MongoDB Charts!MongoDB
These days, everyone is expected to be a data analyst. But with so much data available, how can you make sense of it and be sure you're making the best decisions? One great approach is to use data visualizations. In this session, we take a complex dataset and show how the breadth of capabilities in MongoDB Charts can help you turn bits and bytes into insights.
MongoDB .local San Francisco 2020: From SQL to NoSQL -- Changing Your MindsetMongoDB
When you need to model data, is your first instinct to start breaking it down into rows and columns? Mine used to be too. When you want to develop apps in a modern, agile way, NoSQL databases can be the best option. Come to this talk to learn how to take advantage of all that NoSQL databases have to offer and discover the benefits of changing your mindset from the legacy, tabular way of modeling data. We’ll compare and contrast the terms and concepts in SQL databases and MongoDB, explain the benefits of using MongoDB compared to SQL databases, and walk through data modeling basics so you feel confident as you begin using MongoDB.
MongoDB .local San Francisco 2020: MongoDB Atlas JumpstartMongoDB
Join this talk and test session with a MongoDB Developer Advocate where you'll go over the setup, configuration, and deployment of an Atlas environment. Create a service that you can take back in a production-ready state and prepare to unleash your inner genius.
MongoDB .local San Francisco 2020: Tips and Tricks++ for Querying and Indexin...MongoDB
Query performance should be the unsung hero of an application, but without proper configuration, can become a constant headache. When used properly, MongoDB provides extremely powerful querying capabilities. In this session, we'll discuss concepts like equality, sort, range, managing query predicates versus sequential predicates, and best practices to building multikey indexes.
MongoDB .local San Francisco 2020: Aggregation Pipeline Power++MongoDB
Aggregation pipeline has been able to power your analysis of data since version 2.2. In 4.2 we added more power and now you can use it for more powerful queries, updates, and outputting your data to existing collections. Come hear how you can do everything with the pipeline, including single-view, ETL, data roll-ups and materialized views.
MongoDB .local San Francisco 2020: A Complete Methodology of Data Modeling fo...MongoDB
Are you new to schema design for MongoDB, or are you looking for a more complete or agile process than what you are following currently? In this talk, we will guide you through the phases of a flexible methodology that you can apply to projects ranging from small to large with very demanding requirements.
MongoDB .local San Francisco 2020: MongoDB Atlas Data Lake Technical Deep DiveMongoDB
MongoDB Atlas Data Lake is a new service offered by MongoDB Atlas. Many organizations store long term, archival data in cost-effective storage like S3, GCP, and Azure Blobs. However, many of them do not have robust systems or tools to effectively utilize large amounts of data to inform decision making. MongoDB Atlas Data Lake is a service allowing organizations to analyze their long-term data to discover a wealth of information about their business.
This session will take a deep dive into the features that are currently available in MongoDB Atlas Data Lake and how they are implemented. In addition, we'll discuss future plans and opportunities and offer ample Q&A time with the engineers on the project.
MongoDB .local San Francisco 2020: Developing Alexa Skills with MongoDB & GolangMongoDB
Virtual assistants are becoming the new norm when it comes to daily life, with Amazon’s Alexa being the leader in the space. As a developer, not only do you need to make web and mobile compliant applications, but you need to be able to support virtual assistants like Alexa. However, the process isn’t quite the same between the platforms.
How do you handle requests? Where do you store your data and work with it to create meaningful responses with little delay? How much of your code needs to change between platforms?
In this session we’ll see how to design and develop applications known as Skills for Amazon Alexa powered devices using the Go programming language and MongoDB.
MongoDB .local Paris 2020: Realm : l'ingrédient secret pour de meilleures app...MongoDB
aux Core Data, appréciée par des centaines de milliers de développeurs. Apprenez ce qui rend Realm spécial et comment il peut être utilisé pour créer de meilleures applications plus rapidement.
MongoDB .local Paris 2020: Upply @MongoDB : Upply : Quand le Machine Learning...MongoDB
Il n’a jamais été aussi facile de commander en ligne et de se faire livrer en moins de 48h très souvent gratuitement. Cette simplicité d’usage cache un marché complexe de plus de 8000 milliards de $.
La data est bien connu du monde de la Supply Chain (itinéraires, informations sur les marchandises, douanes,…), mais la valeur de ces données opérationnelles reste peu exploitée. En alliant expertise métier et Data Science, Upply redéfinit les fondamentaux de la Supply Chain en proposant à chacun des acteurs de surmonter la volatilité et l’inefficacité du marché.
MongoDB .local Paris 2020: Les bonnes pratiques pour sécuriser MongoDBMongoDB
Chaque entreprise devient une entreprise de logiciels, fournissant des solutions client pour accéder à une variété de services et d'informations. Les entreprises commencent maintenant à valoriser leurs données et à obtenir de meilleures informations pour l'entreprise. Un défi crucial consiste à s'assurer que ces données sont toujours disponibles et sécurisées pour être conformes aux objectifs commerciaux de l'entreprise et aux contraintes réglementaires des pays. MongoDB fournit la couche de sécurité dont vous avez besoin, venez découvrir comment sécuriser vos données avec MongoDB.
GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using Deplo...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
Elevating Tactical DDD Patterns Through Object CalisthenicsDorra BARTAGUIZ
After immersing yourself in the blue book and its red counterpart, attending DDD-focused conferences, and applying tactical patterns, you're left with a crucial question: How do I ensure my design is effective? Tactical patterns within Domain-Driven Design (DDD) serve as guiding principles for creating clear and manageable domain models. However, achieving success with these patterns requires additional guidance. Interestingly, we've observed that a set of constraints initially designed for training purposes remarkably aligns with effective pattern implementation, offering a more ‘mechanical’ approach. Let's explore together how Object Calisthenics can elevate the design of your tactical DDD patterns, offering concrete help for those venturing into DDD for the first time!
Key Trends Shaping the Future of Infrastructure.pdfCheryl Hung
Keynote at DIGIT West Expo, Glasgow on 29 May 2024.
Cheryl Hung, ochery.com
Sr Director, Infrastructure Ecosystem, Arm.
The key trends across hardware, cloud and open-source; exploring how these areas are likely to mature and develop over the short and long-term, and then considering how organisations can position themselves to adapt and thrive.
Neuro-symbolic is not enough, we need neuro-*semantic*Frank van Harmelen
Neuro-symbolic (NeSy) AI is on the rise. However, simply machine learning on just any symbolic structure is not sufficient to really harvest the gains of NeSy. These will only be gained when the symbolic structures have an actual semantics. I give an operational definition of semantics as “predictable inference”.
All of this illustrated with link prediction over knowledge graphs, but the argument is general.
JMeter webinar - integration with InfluxDB and GrafanaRTTS
Watch this recorded webinar about real-time monitoring of application performance. See how to integrate Apache JMeter, the open-source leader in performance testing, with InfluxDB, the open-source time-series database, and Grafana, the open-source analytics and visualization application.
In this webinar, we will review the benefits of leveraging InfluxDB and Grafana when executing load tests and demonstrate how these tools are used to visualize performance metrics.
Length: 30 minutes
Session Overview
-------------------------------------------
During this webinar, we will cover the following topics while demonstrating the integrations of JMeter, InfluxDB and Grafana:
- What out-of-the-box solutions are available for real-time monitoring JMeter tests?
- What are the benefits of integrating InfluxDB and Grafana into the load testing stack?
- Which features are provided by Grafana?
- Demonstration of InfluxDB and Grafana using a practice web application
To view the webinar recording, go to:
https://www.rttsweb.com/jmeter-integration-webinar
Connector Corner: Automate dynamic content and events by pushing a buttonDianaGray10
Here is something new! In our next Connector Corner webinar, we will demonstrate how you can use a single workflow to:
Create a campaign using Mailchimp with merge tags/fields
Send an interactive Slack channel message (using buttons)
Have the message received by managers and peers along with a test email for review
But there’s more:
In a second workflow supporting the same use case, you’ll see:
Your campaign sent to target colleagues for approval
If the “Approve” button is clicked, a Jira/Zendesk ticket is created for the marketing design team
But—if the “Reject” button is pushed, colleagues will be alerted via Slack message
Join us to learn more about this new, human-in-the-loop capability, brought to you by Integration Service connectors.
And...
Speakers:
Akshay Agnihotri, Product Manager
Charlie Greenberg, Host
Software Delivery At the Speed of AI: Inflectra Invests In AI-Powered QualityInflectra
In this insightful webinar, Inflectra explores how artificial intelligence (AI) is transforming software development and testing. Discover how AI-powered tools are revolutionizing every stage of the software development lifecycle (SDLC), from design and prototyping to testing, deployment, and monitoring.
Learn about:
• The Future of Testing: How AI is shifting testing towards verification, analysis, and higher-level skills, while reducing repetitive tasks.
• Test Automation: How AI-powered test case generation, optimization, and self-healing tests are making testing more efficient and effective.
• Visual Testing: Explore the emerging capabilities of AI in visual testing and how it's set to revolutionize UI verification.
• Inflectra's AI Solutions: See demonstrations of Inflectra's cutting-edge AI tools like the ChatGPT plugin and Azure Open AI platform, designed to streamline your testing process.
Whether you're a developer, tester, or QA professional, this webinar will give you valuable insights into how AI is shaping the future of software delivery.
Kubernetes & AI - Beauty and the Beast !?! @KCD Istanbul 2024Tobias Schneck
As AI technology is pushing into IT I was wondering myself, as an “infrastructure container kubernetes guy”, how get this fancy AI technology get managed from an infrastructure operational view? Is it possible to apply our lovely cloud native principals as well? What benefit’s both technologies could bring to each other?
Let me take this questions and provide you a short journey through existing deployment models and use cases for AI software. On practical examples, we discuss what cloud/on-premise strategy we may need for applying it to our own infrastructure to get it to work from an enterprise perspective. I want to give an overview about infrastructure requirements and technologies, what could be beneficial or limiting your AI use cases in an enterprise environment. An interactive Demo will give you some insides, what approaches I got already working for real.
2. About the speaker
I am Marco Bonezzi:
Senior TSE at MongoDB
TSE = Help customers to be successful with MongoDB
Based in Dublin, Ireland
Experience in databases, distributed systems, high availability
and containers:
4. #MDBW17
THERE ARE COMMON PROBLEMS WHEN
USING CONTAINERS:
Capacity
Connectivity
State
Isolation
Affinity
How do we
manage all
these?
5. #MDBW17
THIS IS WHAT WE WILL LEARN TODAY
1. Deploy MongoDB on containers using Kubernetes
2. Build a StatefulSet for our MongoDB deployment
3. Production-like recommendations for replica sets on GCE
4. High-Availability considerations for a micro-service
application
6. #MDBW17
1. MONGODB ON CONTAINERS USING
KUBERNETES
• Why MongoDB is a good fit for microservices:
• Benefits of using Kubernetes: Automate the distribution and
scheduling of MongoDB containers across a cluster in a more
efficient way.
Time to market Scalability Resiliency
Allignment (API)
Flexible Data
Model
Redundancy
Orchestration Persistency Monitoring
7. #MDBW17
KUBERNETES BUILDING BLOCKS
Node: Provide capacity
o Worker machine for pods (and their containers)
o Virtual or physical
o Can be grouped in a cluster, managed by master
CPU
Memory
CPU
Memory
Pod
Pod
Pod
8. #MDBW17
Pod: Consume capacity
Group of one or more application containers + shared resources for
those containers
container
container
container
container
Volume
Volume
Volume
IP
Image
Port
…
…
POD
9. #MDBW17
Container: Units of packaging
Isolated process. Based on the Linux
kernel:
• Namespaces: what a process can see
• cgroups: what a process can use
Application + dependencies + shared
kernel+ libraries
container
mongod
–dbpath /data/db
--port 27017
container
10. #MDBW17
Service Allow your application to receive traffic
o Logical set of Pods and a policy by which access them
o LabelSelector to define pods targeted
o Types available: ClusterIP, NodePort, LoadBalancer, ExternalName or
Headless Service
Service B: 10.10.9.3
Service A: 10.10.9.4
POD
NODE
11. #MDBW17
BASIC REPLICA SET EXAMPLE
Node
S
P
S
mongod
mongodmongod
https://github.com/kubernetes/minikube
13. #MDBW17
2. BUILDING OUR MONGODB STATEFULSET
• StatefulSet: Designed for applications that require
• Components required:
Stable, unique network
identifiers
mongo-1
mongo-n
...
Volu
me
Volu
medata
Stable, persistent storage
1 2 3 n
Ordered, graceful
deployment and scaling
Ordered, graceful deletion
and terminationPersistent
Volume Claim
Headless
Service
StatefulSet
14. #MDBW17
STATEFULSET
• Provide a unique identity to its Pods, comprised of an ordinal
Identity stays with the Pod, regardless of which node it is scheduled on
Hostnames:
Pods created, scaled and deleted sequentially (i.e. mongo-{0..N-1})
mongo-1 mongo-2mongo-0
BETA FEATURE FROM KUBERNETES
1.5
15. #MDBW17
HEADLESS SERVICE
• Similar to Kubernetes services but without any load balancing
‒ Combined with StatefulSets: unique DNS addresses to access pods
‒ Template for DNS name is <pod-name>.<service-name>
I’m mongo-1.mongo!
Cool, I can add you
two to the replica set
I’m mongo-2.mongo!
rs.initiate()
rs.add(“mongo-1.mongo:27017”)
rs.add(“mongo-2.mongo:27017”)
16. #MDBW17
PERSISTENT STORAGE VOLUMES
• Storage: critical component for Stateful containers
• Dynamic volume provisioning:
Before: provision new storage, then create volume in Kubernetes
Now: dynamic provision using provisioner defined
Persistent
Volume
Physical
Storage
Persistent
Volume
Claim
Persistent
Volume
Persistent
Volume
Claim
POD
POD
StatefulSet
STABLE FROM KUBERNETES
1.6
19. #MDBW17
MONGODB STATEFUL SET
POD - mongo-0
container
(mongod)
POD - mongo-1 POD - mongo-2
SSD
volume
SSD
volume
SSD
volume
Headless Service (*.mongo, 27017)
container
(mongod)
container
(mongod)
Application
20. #MDBW17
SUMMARY: WHAT MAKES STATEFUL SETS
GREAT FOR MONGODB
Unique pod identity
Stable network
Stable storage
Scaling
Known and predictable
hostnames
Persistency resilient to
rescheduling
Scale application reads
Easier to manage
21. #MDBW17
DEMO 2: REPLICA SET AS A STATEFULSET
mongo-watch: https://github.com/sisteming/mongo-
kube/tree/master/mongo-watch
https://github.com/sisteming/mongo-kube/tree/master/demo2
22. #MDBW17
Node 2Node 1
3. ORCHESTRATING AND DEPLOYING
PRODUCTION-LIKE STATEFULSET
Node 0
rs0
• Replica Sets are about High Availability
rs0 rs0
How do we ensure all containers are
evenly distributed?
23. #MDBW17
• Kubernetes cluster
o Coordinate cluster of computers connected to work as a single unit
o Applications decoupled from individual hosts
o Automates the distribution and scheduling of applications containers across
a cluster
• Two main resources
MASTER NODE
Kubelet Docker/rkt
Schedule
applications
Maintain state
Scaling
Rolling updates
Worker machine
Kubelet: Agent (API)
Docker/rkt: Container
runtime
24. #MDBW17
POD SCHEDULING
• Master controls nodes
(minions) via Scheduler
• Responsible for tracking all
resources and pods
• Takes care of:
Resource requirements
Constraints
Affinity/Anti-affinity
25. #MDBW17
SCHEDULING OUR REPLICA SET MEMBERS
nodeSelector Node labels Affinity
Eligible if node has
each of the k-v pairs as
labels
Node 1
mongod-RS1
env: prod
rs: rs0
env: prod
rs: rs0
env: test
rs: rs-t1
mongod-RS1
Hostname
os
Instance
arch
Standard set of labels,
beta.kubernetes.io
Soft/hard constraints
on nodes and pods
nodeAffinity
Affinity or anti-
Affinity
node labels
labels on pods
currently running
BETA FEATURES IN KUBERNETES
1.6
27. #MDBW17
COMPUTE RESOURCES FOR CONTAINERS
We can define how much CPU and memory each container needs
CPU
Memory
Requests
Limits
How much I’d like to get
(scheduling)
The most I can get
(contention)
CPU Units:
spec.containers[].resources.limits.cpu
spec.containers[].resources.requests.cpu
Bytes:
spec.containers[].resources.limits.memory
spec.containers[].resources.requests.memory
Scheduler
Ensures that the sum of the resource requests
of the scheduled containers is less than the
capacity of the node.
28. #MDBW17
HIGH AVAILABILITY IN OUR STATEFULSET
Replicated copy of our data
Automatic failover
Scalability of read operations
Container restart (same node)
Container reschedule (diff. node)
Persistent volumes
MongoDB Replica Set Kubernetes + Stateful Sets
29. #MDBW17
4. MICROSERVICE APPLICATIONS WITH
MONGODB ON KUBERNETES STATEFULSET
Connecting our microservice application (within Kubernetes)
mongodb://mongo-0.mongo,mongo-1.mongo,mongo-
2.mongo:27017/APP_?
Cases to be handled:
o High Availability:
1. Failover (change of primary in the replica set)
2. Pod killed (i.e. Pod is killed and it comes back up)
3. Pod rescheduled (i.e. Node is down and pod gets scheduled to a different node)
o Geographically distributed reads:
1. Read from nearest secondary using ReadPreference + Replica Set tags
31. #MDBW17
DEMO 3: MONGODB REPLICA SET
STATEFULSET ON GOOGLE CLOUD ENGINE
https://github.com/sisteming/mongo-kube/tree/master/demo3
32. #MDBW17
SUMMARY
Key elements for a successful MongoDB Stateful Set on Kubernetes
Resource
requests/limit
s
Persistent
state
Isolation
AffinityScheduling
Unique
network
identifiers
High
Availability
Labels Monitoring
Liveness
Probes
Disruption
Budget
Further improvements
Thank you everybody for being here today for this talk. It is really exciting to be speaking today about these technologies, MongoDB, Docker containers and Kubernetes,
We get many questions on how to combine these technologies successfully and in this talk, you’ll learn some useful information that will help you to build successful micro-services using MongoDB on Kubernetes.
Let me introduce myself, my name is Marco Bonezzi, I’m a Senior TSE (or Technical Services Engineer) at MongoDB.
What TSE really means is that we help customers to be successful with MongoDB by assisting them to make the most from MongoDB for their particular solution.
I am based in Dublin, in Ireland
My main experience is in databases, distributed systems and high availability solutions with different database technologies
In the last few years, microservices architectures have become more and more frequent even for traditinal organisations.
You might be familiar with the 12 factor app: codebase, dependencies, Config,backing services,build-release-run,processes,
All data which needs to be stored must use a stateful backing service, usually a database. And from our experience, MongoDB is a database frequently used to build such microservice architectures.
This also means that we have seen many cases and articles covering both the problems or defects of Docker containers
- How to manage and distribute containers?
- How to combine container technologies with a MongoDB highly available architecture?
- Should I even use containers for stateful applications and store any data?
This doesn’t mean that containers are bad or shouldn’t be used. But it means that there are important things to consider when implemeting our application on a microservice architecture.
It’s easy to find examples on sample apps deployed on containers. But to be successful with containers, we need to manage elements like:
Capacity
Affinity
Isolation, State…
How do we manage this when we only want to deploy our application and make sure it will be resilient and highly available?
We will see how to deploy MongoDB containers in Kubernetes
How we move to the next step, what is a statefulset and how to implement a StatefulSet for our MongoDB replica set
How we manage and orchestrate it using Kubernetes
How a toy microservice application will interact with MongoDB running on a StatefulSet in terms of High Availability
MongoDB is a common datastore frequently used for microservices, due to its features for scalability, high availability or flexible data model.
When talking about microservices, Kubernetes is becoming the default solution to manage and orchestrate containers, and for our MongoDB cluster, it can help us to orchestrate and schedule correctly our containers and also help us with the persistency for each of them.
You may be already familiar with these concepts, but we will cover the basic Kubernetes building blocks required for our MongoDB cluster.
The first element are the nodes, which provide capacity to run our containers or pods. These are the worker machines that will provide resources like memory and CPU for our containers.
In common configurations, nodes are grouped in a cluster, which are managed by a Kubernetes master.
Pods are logical groups of one or more containers + resources for each that can be shared between them like volumes or IP addresses.
They will use the capacity provided by the nodes to run the processes running into each container.
You are all probably aware of what containers are at this point. Containers are generally based on Docker runtime engine where a process in userspace is run in isolation from the rest of the processes in the system. A different defintion can also see “container” is just a term people use to describe a combination of Linux namespaces and cgroups.
The confusion with containers occurs when we assume that they fulfill the same use case as VMs, zones or jails; which they do not. Containers allow for a flexibility and control that is not possible with Jails, Zones, or VMs. And THAT IS A FEATURE.
These features are what is pushing the use of containers as a basic unit of packaging for our applications.
Once we have our containers running, the next step is to allow our application to receive traffic.
This is done by using services, where we define a logical set of pods and a policy by which we will access each of them. For instance, there are different types like NodePort, LoadBalancer or ClusterIP and the decision on which one we’ll use is based on the access pattern required for the type of application we deploy.
Now that we know the basic elements in a Kubernetes deployment, we will start by deploying a really simple replica set with 3 pods, each running the mongod process, in a singe Kubernetes node using minikube.
Minikube runs a single-node Kubernetes cluster inside a VM on your laptop for users looking to try out Kubernetes or develop with it day-to-day.
With these basic steps, we will see how to connect each container to configure the replica set so that we will have a primary node and two secondaries.
You can find the details and steps for this first test in the link above.
In this example, we are using the IP for each pod as by default the hostname won’t be reachable by others.
Ok so we’ve seen how to deploy a replica set in Kubernetes, but this was a very simple and manual approach.
The next step in our journey is now to build a StatefulSet (previously known as petsets) which is a special Kubernetes controller designed for applications that need:
Unique network identifiers
Persistent storage
Ordered, gracefuly deployment, scaling and termination
To create a statefulset, there are some elements we need to create in advance:
Persistent Volumes
Headless service, special for this use case
And then the statefulset itself
Statefulsets were added as beta feature from Kubernetes 1.5, but it is becoming a critical solution for Kubernetes to handle stateful, distributed applications as MongoDB clusters.
One of the key points of StatefulSets is the use of unique identity for each pod, including an ordinal.
This means that the hostname for each pod will be based on the statefulset name + an ordinal and pods will be created, scaled and deleted sequentially based on this identity.
Headless Services in Kubernetes are similar to other services, but without any load balancing, which for our case, makes sense.
Kubernetes schedules a DNS Pod and Service on the cluster. Every Service is assigned a DNS name. Unlike normal Services, this resolves to the set of IPs of the pods selected by the Service.
This means that each pod will be able to contact the rest of pods in the statefulset just by using the statefulset name (mongo), the ordinal (0,1,2) and the headless service (mongo). And this can be quite handy not only for inter-node connectivity (which is based on an overlay network), but also for easier replica set configuration.
Statefulset are aimed to provide a solution to maintain the state for stateful applications. This solution is based on persistent storage and dynamic volume provisioning, included as stable in Kubernetes 1.6.
We have physical storage defined, from which Kubernetes will create Persistent Volumes to be used by the Persistent Volume Claims. From the Pod’s point of view, the claim is a volume.
The difference between PV and PVC is that we can have a PV from which we create multiple PVC with smaller size.
For example, when using minikube, we will have to manually create both PV and PVC. But when deploying on GCE, Azure and AWS, Kubernetes will already have the required provisioner for dynamic provision these elements.
This is an example of a Stateful set yaml configuration file
We can see here the definition of
Service, replicas 3
Labels
Specs and affinity rules we’ll see next
Containers definition and command
Volume mounts and volume cliam templates
Persistent storage
This is an example of a Stateful set yaml configuration file
We can see here the definition of
Service, replicas 3
Labels
Specs and affinity rules we’ll see next
Containers definition and command
Volume mounts and volume cliam templates
Persistent storage
Now that we covered the main components for our MongoDB replica set as a statefulset, we can see here the diagram of the architecture for the Statefulset deployment.
Each container, running the mongod process, will have a unique hostname with an identifier. Each will be also attached to a SSD volume based on Persistent storage on the node where the POD is running. The headless Service then, defined on the default port for MongoDB, means that we will be able to access each node as mongo-0.mongo on the port 27017.
Our application then can connect with these details.
StatefulSets are a great addition to Kubernetes, as it provides better options for distributed applications like MongoDB.
Easier to manage each MongoDB pod
Configure and scale based on predictable hostnames
Persistent volumes bound to each pod, regardless of the node where they run
Increased availability and Scale reads of your application with multiple secondaries
Now that we learned what StatefulSets are and how they can benefit MongoDB running on Kubernetes, we can see how we can implement them.
With StatefulSet and Kubernetes, we can use Kubernetes features like init containers or jobs to configure the MongoDB replica set. In this case, I wrote a simple shell script executed by a Kubernetes job that will monitor the replica set members, configure each of them as primary and secondaries, and eventually also add new members as replica sets if a new container is detected using the hostname convention.
When deploying MongoDB in production, we want to deploy always a replica set, ideally Primary and 2 or more secondaries.
When using containers, it is important to realise that running MongoDB on 3 or more containers for a replica set is not enough. We also need to ensure that each member of the replica set / each container, is located in a different node than the rest of members for the same replica set.
How can we do this with Kubernetes?
For a Production deployment of Kubernetes, we need to build a Kubernetes cluster with 3 or more nodes. They will work as a single unit and automate the distribution and scheduling of applications thanks to the Master node and its integrated scheduler.
The two main resources for a Kubernetes cluster:
Master => Responsible to schedule the applications into each node, to maintain the state as well as to scale or perform rolling updates in a given deployment
Worker nodes => They each have the Kubelet (agent using the API to talk to the API Server) and then Docker or rkt as the container runtime engine responsible of running the containers.
A critical element for every Orchestration tool like Swarm or Kubernetes, is the ability and flexibility to schedule containers to the available worker nodes.
This work is done by the Scheduler process running on the master, which is responsible for tracking all resources and pods.
For example, when we run a pod in Kubernetes, the Scheduler on the master will check which nodes are eligible to meet:
Any resource requirements from the pod
Any constraints defined in the pod definition (like labels for the environment type)
Affinity or anti-affinity requested by the pod, both inter-node and inter-pod
Once we know we have to distribute each replica set member / each container across different nodes, we need to think at ways of doing this in an automated way.
We have different options to do this, but the most relevant are:
nodeSelector: filter eligible nodes based on labels (like replica set or type of environment)
Node labels: Hostname, instance type or OS (for example, avoid a specific hostname or OS)
Affinity: Soft or hard constraints on nodes and pods running on nodes. (for example, if a given pod is running on a given node, don’t pick that node)
This last concept of affinity or anti-affinity is actually really useful and can help us whith our purpose: we can define a hard affinity constraint so that the Scheduler wont schedule a pod for rs1 on a node where there is already a pod for rs1 running.
https://kubernetes.io/docs/concepts/configuration/assign-pod-node/
Based on this logic, we can see how it is fairly easy to define this type of pod affinity constraint just based on key-value expressions.
In this example, we have a cluster created on Google Cloud, where each node is located in a different zone within europe-west. With this approach, we can deploy each container for rs1 (mongo-0, mongo-1 and mongo-2) onto each of these nodes.
We can see with get pod –o wide the actual node where the pods are running and how we achieved our goal of having each pod in a different node.
This also means that, when using such a hard affinity constraint, If let’s say node1 becomes unavailable, it won’t be possible to schedule a pod for rs1 on the 2 remaining nodes. TRADEOFF
scheduler } Warning FailedScheduling No nodes are available that match all of the following predicates:: NoVolumeZoneConflict (2).
A key element to be aware of is the resources used by each container.
By default there will be no resource request or limit set. But it is a good practice in particular with databases as MongoDB to define the expected boundaries for the resource utilization, as this will help to prevent performance issues due to resource contention (multiple containers on same node)
In Kubernetes, we can define request (how much the container would like to get) and limits (how much the container can get). An important point here is that the WiredTiger cache size in MongoDB is based on the total memory on the system, not on the container. It is critical then to set the cache size manually to 50% of the memory limit we define.
The Kubernetes scheduler compare the resource requests to the capacity in the available nodes, and will select the target node also based on this capacity.
Important to understand application behaviour when reaching for example the memory limit, as this can trigger unexpected behaviours or even the pod to be terminated.
Availability of our micro-service application is important so we can see the benefits from MongoDB and Kubernetes:
The use of replica set will guarantee the high availability by having:
- replicated copy of our data,
- automatic failover
- further scalability of read operations by scaling the number of secondary nodes.
In addition to this, Kubernetes StatefulSets provide us with increased availability as:
Containers killed/delete are restarted on the same node
In case of a node becoming unavailable, containers will be re-scheduled to different available nodes
Persistent volumes are bound to the container, so even when a node becomes unavailable, the container rescheduled on a different node will be able to use its previously used persistent volume.
At this point, we have a fully configured replica set running on a Kubernetes StatefulSet.
With this, we can then connect our micro-service application by providing the connecting string of the replica set, with all nodes involved.
There is a great talk from last year MongoDB World from my colleague Jesse: MongoDB World 2016: Smart Strategies for Resilient Applications
In summary, the cases we need to handle are:
HA
Failover (change of primary)
A pod gets killed
A Pod is rescheduled to a different node
Scalability
Scale the reads with multiple secondaries
MongoDB World 2016: Smart Strategies for Resilient Applications
In summary, we have seen the various building blocks of Kubernetes, and how we can implement a MongoDB replica set using StatefulSets in Kubernetes.
While this might seem complex, we can see how we handled Scheduling, affinity, resource requests and limits thanks to cgroups, how statefulset provide us with Unique network identifiers and persistent state for our MongoDB replica set, and how we can handle isolation and high availability by using labels and affiniity rules.
Possible improvements can include:
Liveness probes: tests to detect if the service from a container is alive
Disruption Budget: What is the minimal configuration in terms of pods and nodes that our application or service can afford
In Summary, we can see how the use of containers and Kubernetes is not only getting our application to run on containers, but once we are there, there are multiple features that we can use to improve the availability and resiliency of our applications, which at the end of the day can help our lives as engineers but also the business of our companies.