28:16
2025-01-27 13:22:37
2:15:00
2025-01-27 15:12:42
2:08:39
2025-01-27 15:41:27
2:16:52
2025-01-27 20:41:38
3:55:27
2025-01-27 20:41:42
4:47:11
2025-01-28 08:47:09
Visit the Mongo DB for Administrators course recordings page
WEBVTT
-->
Yes?
-->
Why are you putting your stuff there?
-->
Why are you wearing your top like this?
-->
It's because...
-->
It's because I'm...
-->
Why are you putting your top there?
-->
Why are you both not sleeping?
-->
Why are you both not sleeping?
-->
I'm not tired yet.
-->
Both of you?
-->
Okay?
-->
I'm in the kitchen. I'm burning.
-->
Yeah.
-->
How are you?
-->
How are you?
-->
Sorry?
-->
How are you?
-->
I'm burning right now.
-->
I want to say that I can be able to help you on Thursday.
-->
Sorry?
-->
Yeah, I can be able to help you on Thursday.
-->
Okay.
-->
Alright.
-->
No problem.
-->
Let's talk when you're done.
-->
I need to concentrate on something here.
-->
Huh?
-->
Please just end it on that side.
-->
I don't know.
-->
I mean, yes.
-->
I mean, yes, what?
-->
It's complicated.
-->
Feelings are never complicated.
-->
Either you like them, or you're afraid.
-->
But it doesn't matter, okay?
-->
We've decided on a way forward, we agreed.
-->
Just...
-->
Are you changing your mind?
-->
No, no, no, no.
-->
What's up?
-->
Oh, should I have called first?
-->
No, no, no.
-->
It's okay.
-->
I can imagine.
-->
Hey.
-->
Seems very odd, doesn't it?
-->
Like, what happened?
-->
Yes, yes, of course.
-->
I don't know.
-->
Oh, of course.
-->
That's very kind of you.
-->
It used to be.
-->
Not anymore.
-->
Like it says.
-->
Why would you?
-->
You haven't made breakfast for me since I was like 10 years old.
-->
Well...
-->
I love this.
-->
Pancakes, waffles.
-->
Hey!
-->
Pick us up already.
-->
Yes, my boy.
-->
Not even.
-->
I'm going to get a coffee.
-->
Yes, my boy.
-->
I'll be back in a minute.
-->
I'm going to get a coffee.
-->
You're right about that.
-->
You're right about that.
-->
I'm going to get a coffee.
-->
So, tell him to pick up lines this inch.
-->
I'm coming for a minimum of five and a half.
-->
Yes, yes, yes.
-->
I'm going to get a coffee.
-->
Tell him I'll be back in a minute.
-->
Right, my boy.
-->
Go on!
-->
How much is?
-->
Yeah, okay, the CEO of Triple M Media.
-->
Yes, we are going to the special commission because don't you see what this means?
-->
Media doesn't have to honor political commitments like his way. I think we need to partner with them.
-->
Is there anyone you do get along with Jack?
-->
I've been pulling all nighters to find solutions. This is our best bet.
-->
Just swallow your pride and play nice with her.
-->
Then I guess I'll have to put it in my report to Volkov.
-->
I'm sure he won't be happy to hear that you're the one standing in the way of his plans.
-->
And the only way for me to get answers is to spend more time at the center.
-->
And make Esther suspicious.
-->
So in other words, if I actually do the profile, it'll be great publicity.
-->
What if there is no sort?
-->
A group of girls walks into the safe house saying the exact same thing.
-->
You can't force them to speak to you.
-->
So I can prevent them and expose them to the world when they're already so traumatized.
-->
We are moving into very dangerous territory.
-->
I am not comfortable with this.
-->
Not even if it's for the greater good.
-->
If we find the truth, we might actually help these girls.
-->
We could even stop other girls from becoming victims.
-->
Trust me, that way he's more likely to come back to us.
-->
I'm sorry.
-->
Over 20 years, people take some main changes.
-->
We're just not in your league.
-->
No.
-->
They can't even get back.
-->
Forgive me.
-->
I can't help it.
-->
You can't refer to that way.
-->
I have to keep it easy.
-->
You have to go put down your forgive.
-->
Why don't you refer to that way?
-->
I thought we were starting to be friends again.
-->
I'm just tired.
-->
You need me.
-->
You can't even look at me.
-->
No.
-->
I'm kind of misinterpreted.
-->
You have a connection.
-->
You were giving me something that my husband wasn't.
-->
It was never about love.
-->
Where is this coming from?
-->
Well, in a curious way, that's all.
-->
Please.
-->
What are you going to do with yourself, James?
-->
Unless it's for the story.
-->
That's not nice.
-->
There's a fact.
-->
Hey.
-->
Hey.
-->
Hey.
-->
What?
-->
Can I?
-->
I'm sick.
-->
What?
-->
No way, sir.
-->
I'm sick.
-->
That was a no.
-->
Really?
-->
Okay.
-->
It's not that funny.
-->
And I think you're acting very strange.
-->
I'm not as pretty as her.
-->
I think I'm a bit cooler.
-->
Oh.
-->
Maybe if I never had to move.
-->
So I could get out of here.
-->
Okay.
-->
I have to go now.
-->
Bye.
-->
Okay.
-->
Bye, ma.
-->
I'm ready.
-->
You're not.
-->
You're not.
-->
That's my boy.
-->
Bye.
-->
I'm ready.
-->
It's a close.
-->
You know.
-->
I know.
-->
Yeah.
-->
What's the matter?
-->
I feel like I'm in business.
-->
You know that.
-->
I feel like I'm in business.
-->
I mean.
-->
I mean, I had no time for school or books.
-->
Not likely.
-->
The industry grades started when they were young.
-->
Okay.
-->
Give us a little bit longer.
-->
That's fair.
-->
Yeah.
-->
Young and gentle, isn't it?
-->
We'll move on about over.
-->
We haven't turned down.
-->
It's fine.
-->
Excellent.
-->
I'm not cool for years.
-->
I'll probably never find another guy.
-->
I'll move on.
-->
I'll always be there.
-->
You feel me?
-->
It's me.
-->
It's just fine.
-->
What reason to believe?
-->
In years.
-->
That's what has a healing joy in.
-->
You do the math.
-->
You don't have time for that.
-->
Everything is part time.
-->
You're an actor.
-->
I'm not afraid of anything.
-->
You're the only person in my life.
-->
I'm not afraid of anything.
-->
Me neither.
-->
Me neither.
-->
You do the math.
-->
I'm the best out there.
-->
Then you know.
-->
Do you want to go out?
-->
ლ ლ ლ ლ ლ ლ ლ, ლ ყ, ლ
-->
ლ ლ ლ ლ შ ხ ყ ა� ი mould
-->
ლ ლ უ შ ლ ლ xami, ც თ ნ ე ღ ი ვ, ე
-->
ლ ნ მ ჭ ხ ხ ს ლ უ რ ს ნ ს ი უ � ჩ � St.
-->
მ მ ფ ა � beiShihak you
-->
["I'm sorry guys, sorry.".
-->
Whenever you have the courage, speed up your brain and calm down your head.]
-->
ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha ha
-->
Okay.
-->
Okay.
-->
Okay. Okay.
-->
Okay.
-->
I have good news and bad news.
-->
I'm good.
-->
I'm good.
-->
I'm good.
-->
I love you.
-->
I love you.
-->
Oh.
-->
Sorry, sorry.
-->
Yeah.
-->
You know, I love you. I miss you.
-->
Before I get my car, I'm
-->
Before I get my car, I'm
-->
Before I get my car, I'm going to be.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
It's a foodie.
-->
It's a foodie.
-->
It's a foodie.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
I'm.
-->
3-5minutes also, I'll be with you guys.
-->
Morning.
-->
Morning.
-->
Okay, cool. I am here.
-->
Any questions from yesterday?
-->
I presume none.
-->
Okay.
-->
So we will continue, just one second.
-->
Slide show.
-->
Play from current.
-->
Okay.
-->
Can you guys see my screen?
-->
Yes.
-->
Okay, cool.
-->
Now, let's continue today and talk about drivers, right?
-->
When you're writing code, right, for those that were developers mainly, or if you were developers,
-->
there is a way to be able to write code that will insert data into the database.
-->
Remember, there is the one of writing a query path, right?
-->
When you're in the database in itself and then when you're using programming languages,
-->
different programming languages.
-->
Yes.
-->
Can we please start the recording?
-->
Oh, yes, please.
-->
Thank you.
-->
Let me know when you are ready.
-->
When it starts recording.
-->
Yes, thank you.
-->
Oh, okay, cool.
-->
Yes.
-->
Let me share.
-->
Okay.
-->
Can you see my screen?
-->
Okay, so I was saying when you are writing code in different languages, your Java, your Python,
-->
there is a communication that needs to happen between the database and the application in itself.
-->
And what MongoDB uses is what you call drivers, right?
-->
So the interaction between the language in itself or the library module or the language in itself
-->
and the database is mainly connected or the interaction happened using what you call a driver.
-->
And what is a driver?
-->
It's a library or module that allows your application, right, to communicate with MongoDB, right?
-->
Yes.
-->
Oh, I was on mute.
-->
Sorry, guys.
-->
Yeah.
-->
Sorry.
-->
I forgot that it's when you start recording when your site goes on mute and whatnot.
-->
But anyway.
-->
So I was saying that the communication between a language, right?
-->
Specific programming language and MongoDB is done using what you call a driver, right?
-->
And what is a driver?
-->
It's merely a library or a module that allows your application to be able to communicate with MongoDB, right?
-->
Mongo, the driver obviously will handle the lower level details of connecting to the database,
-->
sending the queries, receiving the responses and all that stuff, right?
-->
And with Mongo, it has official drivers for many languages, right?
-->
Your Java, your Python, your Perl and all that stuff.
-->
And key responsibilities of those Mongo drivers is first, connection management.
-->
It establishes the connection and manages those connections to the MongoDB server, right?
-->
When you write a query, when you send a query,
-->
it handles that from the programming languages converted to whatever is MongoDB related side of it
-->
and also converting data between the database, the database BSON and the language, right?
-->
So it still needs to give an output that is understood by the programming language
-->
that you're using.
-->
So that conversion from the programming language to BSON and then from BSON back to the programming languages, right?
-->
It also is able to handle errors, right, and exceptions.
-->
So whenever there's an issue, then it can be able to handle errors, right?
-->
And then it also has features like connection pooling, connection pooling and batching for efficient communication.
-->
So connection pooling is when you open a number of connections to be able to have parallel connections
-->
and be able to sort of process some tasks in parallel, right?
-->
So how do drivers and the shell work with the shell or the MongoDB, right?
-->
So firstly, there's the communication protocol, right?
-->
The way both the drivers and the Mongo shell communicate with the MongoDB using...
-->
Okay, what happened to my sharing now?
-->
Did someone take over the screen because the sharing just stopped?
-->
Can you see my screen now?
-->
Yes.
-->
Okay, cool.
-->
So I was talking about drivers and shell communication with MongoDB.
-->
So what happens is you've got the drivers and the Mongo shell, right?
-->
And of which they communicate with the MongoDB using what you call a MongoDB wire protocol, right?
-->
It's a binary protocol basically that defines how the messages are structured and transmitted between the two,
-->
the client, which is the driver or shell, and the servers, right?
-->
And then also there's the part where there's the data exchanged in BSON format, right?
-->
It comes in as whatever language it is, it's binary encoded and serialized into JSON-like documents,
-->
which is BSON, goes into the MongoDB server.
-->
It's processed and then taken back as plain JSON, for example, right?
-->
And then there's the connection to the MongoDB where the driver is responsible for that connection.
-->
So it establishes that connection between the client and the MongoDB server, right?
-->
It also does the managing of the connection pools, right?
-->
And then you've got the shell, which is the MongoDB shell, which is the MongoSH,
-->
which then connects to the server using a similar connection string, you know?
-->
And then the drivers in itself using the drivers API can be able to send commands to MongoDB.
-->
So in Python, for example, db.collection.find to query documents.
-->
So you can actually write your query like that.
-->
The API of the driver can be able to actually send that to the MongoDB server.
-->
And then in regards to the shell, you type commands directly into the shell.
-->
So it's the same way that you'd be able to do.
-->
So it differs with programming languages.
-->
So, for example, in Python, you use db.collection.find.
-->
In Java, you just use collection.find.
-->
But they both interpret to the shell part being db.collection.find, right?
-->
And then at the other end, it also receives the responses.
-->
So responses that come back, MongoDB uses BSON format, right?
-->
So it sends back in BSON format.
-->
What the drivers do is they then take that BSON format
-->
and then convert it to the data structure for the programming language, right?
-->
For example, it could be JSON, or it could be a dictionary in Python, or it could be an object, right?
-->
It's able to then convert the data, right?
-->
Usually the most used, I think the most easiest and used response in most languages would be JSON, right?
-->
And then it also does error handling, as we spoke about it.
-->
If error is okay, let's say there's a network issue or there's an error message back to the client,
-->
it's able to actually convert it, be able to showcase that this is the error,
-->
and you can then do some troubleshooting.
-->
Now let's talk about the binary JSON, right?
-->
Binary JSON, which is BSON, which is binary JSON, is binary coded serialization of JSON-like documents.
-->
So when you see it, it's like a JSON document, JSON document, right?
-->
The structure in itself is like a JSON anyway, right?
-->
The BSON part of it is designed to be more efficient for storage and network transmission, right?
-->
So which means that it's compressed.
-->
It's a bit smaller in terms of what you call the size of it, right?
-->
And then BSON also extends that by adding your additional data types, your dates, your binary data, and all that stuff, right?
-->
And why did MongoDB choose this specific one, BSON?
-->
BSON is more compact.
-->
It's way more compact and faster to pass than JSON, right?
-->
Which means it's smaller and easier to process, quicker to process.
-->
And then it's got rich data types.
-->
Your date, your binary data, your object ID, 32 and 64-bit integers, you know, and decimals, 128, right?
-->
And it's also compatible anyway with MongoDB because it stores data in BSON format, right?
-->
And it ensures that there's that seamless communication between the database and the applications, right?
-->
And how does it, how does BSON work in MongoDB, right?
-->
When you insert a document, for example, right?
-->
The driver converts it from the language native format, which is obviously the Python or the Java, into BSON.
-->
And then that's when it will be able to be processed, right?
-->
And then when you query the data, MongoDB then returns the results in a BSON.
-->
And then the driver converts it back into the language's native format, right?
-->
And then you've got the MongoDB wire protocol, which is a protocol that defines how the clients communicate to the MongoDB, right?
-->
With the MongoDB server, right?
-->
And it specifies the format of the messages sent.
-->
So including the query request, instead of data delete commands, what is it that you're going to be doing?
-->
What is it that you're getting back?
-->
The results that you're getting back from the server, right?
-->
And it's a protocol that is designed to be lightweight and efficient, right?
-->
It's lightweight, it's efficient, and it makes it suitable for high-performance applications because it's lightweight and efficient.
-->
It's very quick in its processing, you know?
-->
And some key features of that wire protocol obviously is the binary format, where messages are transmitted in binary and it is faster to pass and more compact, right?
-->
And then if the client sends a request, which is a query, and it sends back a response, right?
-->
And then it's got this support for BSON, where you can be able to have a BSON format.
-->
It then is able to actually assist in connecting with the driver and all that stuff.
-->
And then it also does connection handling, where it supports your connection pulling, your keeper life to improve performance, and all that stuff, right?
-->
Some key differences between BSON and the wire protocol.
-->
The purpose, BSON is for data format for storage and transmission, and then the MongoDB is obvious.
-->
The wire protocol is for communication protocol between client and server.
-->
And then BSON is binary encoded, JSON-like documents, and then the wire protocol is binary messages with the headers and payloads, right?
-->
And then usage, you use to represent documents in MongoDB, and then the wire protocol is used to send and receive messages between client and server.
-->
And then some data types, BSON supports your date, object ID, binary data, and all that stuff.
-->
And then the wire protocol defines how operations of the responses are structured.
-->
Any questions on that?
-->
No, no question.
-->
All right, cool.
-->
Let's talk about some troubleshooting, right? Your application connections.
-->
So sort of some things that you need to look at, right?
-->
Let's say there's an incorrect, the error is an incorrect connection string, right?
-->
It might fail because of that, right? So your URI might be missing some required parameters.
-->
You need to check your typos or you could be using incorrect credentials, right?
-->
If there's a network issue, then, for example, application might not be able to reach the MongoDB, right?
-->
You need to check things like your file, any DNS, any IP, any host name, if there was any error in regards to that.
-->
And then authentication failures, right?
-->
It could be an incorrect username or password or some missing or incorrect authentication database,
-->
which is on the MongoDB side or user might not have the required permissions, for example.
-->
I remember yesterday there was a user when we had admin, we couldn't create something after creating it.
-->
So that could be another issue.
-->
And then MongoDB server not running, so the service in itself, the server in itself might not be running.
-->
So you might want to check if it's down or it's properly configured to be able to accept connections.
-->
And then there could be a drive or library issue.
-->
It's either it's incompatible or it's outdated and what do you call this?
-->
Or there could be missing dependencies or incorrect driver configuration.
-->
These are things that you need to be able to look at.
-->
And then there also might be resource limitations where there is heavy load or have reached its connection limit.
-->
It's things that you can also be able to look at.
-->
And then TLS and SSL misconfiguration.
-->
This one can be a very big one because it can bring your whole system down when you don't configure your certificates properly.
-->
You know, it's a very, very big one.
-->
So anything that involves SSL, if it's not configured properly, then it can be a big issue.
-->
Now, let's talk about some scaling, right?
-->
We want to scale some write and read and write scaling, right?
-->
And of which scaling is obviously being is the ability for a system to be able to handle increased load, right?
-->
And MongoDB has two main ones, right?
-->
There's the vertical one and the horizontal.
-->
The vertical one is more or less increasing the capacity of a single server, right?
-->
So you're adding more CPU or RAM or storage.
-->
And then some use cases, obviously suitable for small medium workloads.
-->
The only limitation is hardware constraints, right?
-->
If you don't have enough hardware, then there's that limited constraint.
-->
And then there's the horizontal scaling, which is the distributing the load across multiple servers, right?
-->
As much as yes, the limitation is also the hardware that you have.
-->
But also if you can convert that into virtual servers and all that stuff, it could assist.
-->
And this is usually ideal for large scale applications that have got a very high read and write demand, right?
-->
And how does MongoDB achieve this when it's horizontal scaling?
-->
There's what you call sharding.
-->
Sharding is more or less splitting data across multiple servers, right, to distribute the load.
-->
And shards is putting them in small chunks, right?
-->
And then there's also replication where you maintain multiple copies of data to improve read scalability and fault tolerance, right?
-->
Now let's look at replication. Replication is where you've got data, the same data across multiple servers, right?
-->
And you ensure that there is that high availability and fault tolerance.
-->
And if the primary replica goes down, a secondary replica can kick in and it wouldn't have any issue because it's updated.
-->
It's got all. Well, we are saying theoretically we are saying that everything will be up to date, right?
-->
There is no technical issue that could be happening and all that stuff, right?
-->
And what is replication is, is where there's a group of MongoDB instances that maintain the same data, right?
-->
There's the primary node which handles your read, all your write operations and replicates data across to the secondary nodes.
-->
And then there's the secondary node which handles the read, right?
-->
It can handle the read operations and this is where your replicated data is stored, right?
-->
And then you've got an arbiter, where this is an optional one, as you spoke the last time, that the lightweight member that participates in the election but doesn't store data.
-->
Its purpose is just to be able to determine which one is the primary node today, you know, it's an optional one.
-->
So getting to how replication works, the first thing is the write operation.
-->
So all write operations go to the primary node, right?
-->
It records the changes in its operation log and then the secondary nodes asynchronously replicate the op log and apply the changes to their own data, right?
-->
And then what then happens is when the read operations happen, reads are directed to the primary node,
-->
but you can also configure to say, let the read happen on secondary node, for example, any of the secondary nodes, right?
-->
So that it improves the operations, you leave the write operations to just the primary node and you have the secondary node being the read ones.
-->
And then benefits of replication, right?
-->
So obviously, when primary node fails, it automatically switches to the next one by election process, which would obviously be one of the secondary ones and then it becomes the primary.
-->
And then secondary nodes can handle read operations, right?
-->
So reducing the load on the primary and then data durability, there's that multiple copies of data that is ensured.
-->
So even if one server fails, you still have a copy of what you call this, of the data in another server, right?
-->
Let's go on to durability, durability where it ensures that once a write operation is acknowledged, right?
-->
The data is safely stored and won't be lost, right?
-->
Even in the case of a failure.
-->
So how does MongoDB do that?
-->
So there's what you call a write content, right?
-->
The write content specifies the level of acknowledgement required for a write operation, right?
-->
So, for example, if it's one, it's acknowledged by the primary node, which is the default.
-->
There is majority, which is acknowledged by majority of nodes in the replica set.
-->
Or two is got, it says, acknowledged by at least two nodes.
-->
So at least two nodes should be able to confirm that they've written the same data and they've written the same data.
-->
And then it will be like, OK, this is fine now, right?
-->
And higher write content levels increase durability.
-->
So the more, the higher you put it, the more there is that durability.
-->
But also be mindful of performance, because if you've got a hundred servers that need to be written and you need acknowledgement from 50, it might take time.
-->
It's compared if you just need acknowledgement from, let's say, five servers and then it's confirmed as good.
-->
Then you know that at least two to be quick, you know.
-->
And then there's journaling.
-->
Journaling is where your MongoDB uses a write ahead log, right, to ensure data durability.
-->
And then before applying any changes to the data file, MongoDB writes them to a journal.
-->
It's like just writing in a diary or something, right?
-->
And then in case of a class, the journal can be used to recover data.
-->
So you can be able to use that journal to be able to cover your data because you just go into a journal and be able to cover that data.
-->
It's very, very recommended to have journaling in place, because that way, if there is a situation, you can be able to recover to the last available data.
-->
Right. And then there's replication where you replicate obviously data to the different nodes.
-->
But there are some trade-offs, right, where there's performance versus durability.
-->
High durability, which is more or less, let's say, majority, can slow down your write operation.
-->
Right. Because there is increased number of acknowledgement that is required.
-->
Right. And so you need to be careful.
-->
You need to have the trade-offs.
-->
And then the configuration wise, you need to choose the right balance based on your application requirements.
-->
So you need to have that sort of you need to look at, OK, what is it exactly that works for us?
-->
Should I just have small number?
-->
Should I have majority of acknowledgement and all that stuff?
-->
Right. Then you can be able to combine scalability, replication and durability.
-->
Right. So you can have read scalability, for example, using your secondary nodes to be able to fall for your read.
-->
Right. That way you distribute your read to your secondary nodes and then you configure read preferences.
-->
Right. To your to direct configure read preferences to direct reads to secondary.
-->
Right. So primary, you're left with just the rights.
-->
Right. Leave it. Don't use that as the read, although it is by default, but direct all the reads to go to the secondaries.
-->
And then you can also be able to direct it to the nearest.
-->
So you can direct it to the node, the lowest network latency available.
-->
That's another way of doing read scalability and then write scalability to use sharding to distribute your rights across multiple shards.
-->
Right. And each shard can be a replica set, combining horizontal scaling with replication.
-->
So you can be able to combine both.
-->
And then durability wise, you can then use your right concern in journaling so that you ensure data is safely stored.
-->
And then replication also provides that additional layer of durability by maintaining multiple copies of data.
-->
So you can actually incorporate all these, what's called all these three and be able to have quite optimized system.
-->
Some best practices to it use replica sets, always deploy MongoDB with the replica set.
-->
Right. That way it helps in high availability and for tolerance and then monitor performance.
-->
Tools like MongoDB Atlas or MongoStat can help you to monitor your read write performances and also external tools that you can use your Prometheus, your Grafana and then optimize sharding.
-->
Choose a shard key that distributes data evenly across hotspots and avoid, sorry, and avoid hotspots.
-->
So avoiding hotspots is avoiding just one shard being the one that's fed the data.
-->
Right. So you spread them evenly and then regularly test your replica sets failover.
-->
Sit off one replica and see what happens, you know, and then balance durability.
-->
Choose the right, the right concern and journaling settings based on your application needs.
-->
Questions before we go to the next one?
-->
Absolutely. No question from my side.
-->
All right. Winnie, are you there?
-->
Yes, I'm here. No questions from me. Thank you.
-->
All right. Cool.
-->
Let's talk about master slave replication, right?
-->
It's now legacy.
-->
So you find that there is probably some what you call the some organization that still have the legacy MongoDB.
-->
It's outdated, but you're going to speak about it.
-->
It's more or less like your normal replication, just that it's now legacy.
-->
Right. So you've got your master and your slave, your master node handling all right operations and is the primary source of truth.
-->
And you've got the slave node, which replicates data from master and can be able to read operations.
-->
Right. Some characteristics of it.
-->
One way replication. So data flows only from the master to the slaves.
-->
No automatic failover.
-->
So if master failover, then you have to have a manual intervention to be able to promote a slave to a master and then limited scalability.
-->
Only the master can handle rights, which can become a bottleneck.
-->
How does it work?
-->
Right. Operations or insert updates and deletes are sent to the master nodes.
-->
And then the master records the changes in the operation log.
-->
And then slave nodes asynchronously pull the changes from the master's log.
-->
Right. And apply them to their own data.
-->
Right. And then the read operations by default are directed to the master nodes.
-->
But also you can be able to configure slaves to handle read operations, which improves read scalability.
-->
There is a very thin line between master slave replication and the replica sets.
-->
Right. And then why master slave replication is depleted.
-->
So there's there was some limitations to it.
-->
Right. In favor of replica sets.
-->
So no automatic failover, which is a very big one.
-->
If there's an issue, then you go have to promote the slave into master.
-->
But now we're talking about downtime at that time.
-->
Loss of data at the time. Right.
-->
Limited fault tolerance. Right.
-->
Only one master exists. So which is a single point of failure.
-->
And then you've got no built in election.
-->
So, for example, the arbiter, you can be able to use the arbiter to do the election of a new primary.
-->
Right. In the replica sets.
-->
But with this one, it doesn't have.
-->
And then there is no support for modern features.
-->
Your arbiters, your priority setting, your right concern, which then makes it deprecated.
-->
Right. But some best practices when you have that legacy system is monitor the master node.
-->
It's the most important one.
-->
You need to make sure that you're monitoring its health and performance and then configure slave nodes for its scaling.
-->
Right.
-->
Configure that your reading goes your read operations go to the slave so that you listen the load on the master and then plan for manual fail over.
-->
You have a documented process, you know, for promoting slave to master in case of a failure.
-->
And then backup data regularly using your mongo dam, your file system, snapshots and all that stuff.
-->
And then upgrades to replica as soon as possible.
-->
When you can write, you can be able to do that migration from master to master slave replication to replica sets.
-->
And then replica sets obviously have the advantage of automatic fail of better for tolerance.
-->
There's some some modern features.
-->
So how then do you do your migrating from master slave to replica sets?
-->
The very first thing is stop rights to the master.
-->
Right.
-->
Temporarily stop your right operations.
-->
The master node adds slave nodes to the replica set.
-->
So you restart the master and slaves as part of a replica set and then initialize your replica set.
-->
Right.
-->
You connect to the master node and run the replica set in this initiate command.
-->
And then you add the slave nodes using the replica replica set.
-->
And then simulate a failure of the primary node and ensure the secondary is automatically promoted.
-->
And then update your application configuration or connection strings to be able to point at that replica set.
-->
Is anyone familiar with Kubernetes?
-->
Not much on my side, but yeah, it's something that I'm interested in.
-->
Yeah, it's a very interesting one.
-->
Because I know it's about micros, so it can handle microservices.
-->
Basically, it's instead of using the traditional dedicated host or server, they need to have containers and portion your microservices or applications.
-->
Yeah, definitely.
-->
It's a very good tool.
-->
I would advise anyone to look into it, companies to look into it, because it helps a lot in terms of high availability scaling, because there is that automated scaling that happens with it.
-->
You also break your system into smaller chunks.
-->
So you have a situation where if people can't log in, it doesn't mean that somebody that's logged in already has issues.
-->
It will just be the logging in that's the problem.
-->
So you just need to fix that.
-->
The rest will still be up and running, you know, as an example, which is very, very good.
-->
That's another, that's another technology where replica sets are used.
-->
So in essence, you would say your replica set in Kubernetes, you want to have a minimum of four containers that represent login, login, right?
-->
Your authentication.
-->
So you tell Kubernetes that I want a minimum of four, I want a maximum of ten, right?
-->
So automatically when there is pressure on the logging in, it increases the number of replicas, right?
-->
According to obviously what you would have said in terms of usage, let's say CPU usage, for example, average CPU usage when it gets to 70, then create another replica.
-->
That's another technology that uses the replica sets in a way that replica sets should be used.
-->
So it's worth looking at.
-->
So what is a replica set?
-->
Obviously MongoDB is a group of MongoDB instances that maintain the same data.
-->
It helps in terms of high availability, where you've got the automatic failover, some data redundancy, where you've got multiple copies of data across different servers and then read scalability.
-->
The way you've got secondary nodes where that can handle what you call this that can handle read operation.
-->
And then some key components of a replica set.
-->
You've got the primary node obviously handling all the right operations, does the recording of changes in the operation log and then replicates data to the secondary nodes.
-->
Then you've got the secondary nodes which replicate data from the primary, can handle read operations if you configure that and then it can participate in elections to select a new primary.
-->
If the current primary fails and then you've got an arbiter which does the election, but it doesn't store data.
-->
And then you've got the up log, the up log which is a kept collection that records all right operations.
-->
So anything that's written is logged into that and then used by secondary nodes to replicate data.
-->
Right.
-->
How do replica sets work?
-->
Firstly, all right operations go to the primary nodes.
-->
The primary node records the changes into the up log.
-->
And then there's the data application where asynchronously secondary nodes pull the changes from the primary's up log and apply them to their own data.
-->
And then this ensures all nodes in the replica set of the same data.
-->
And then the read operations by default read is directed to the primary node.
-->
But you can then configure read preferences to be distributed to the secondary nodes.
-->
And then you've got automatic failover.
-->
If a primary node fails, an automatic election process happens.
-->
Right.
-->
And then a new primary for the secondary nodes then is then promoted.
-->
Right.
-->
And factors that it's based on, it could be priority.
-->
It could be not held.
-->
It could be 14.
-->
So those are some of the ways that it can be able to do that.
-->
So a replica set configuration, for example, your replica set should have members.
-->
So there's host, host one, which is Mongo Mongo one, priority two.
-->
Mongo two is priority one.
-->
And then Mongo three is the arbiter.
-->
Right.
-->
So it doesn't, there Mongo three doesn't store anything.
-->
It just helps in terms of the voting process of making the what you call this between one and two,
-->
making it the primary in case there's a there's a situation.
-->
Right.
-->
And I did the name of the replica set.
-->
And then you've got members, an array of nodes in the replica set.
-->
And then priority in the likelihood of a node becoming primary, the higher values goes to higher priority.
-->
And obviously, the arbiter only marks the node as an arbiter.
-->
And that one does the voting.
-->
Some best practices to replica sets using odd number of nodes.
-->
Right.
-->
Always the plain odd number of nodes, three, five, so that you have proper elections.
-->
I don't I've never got to understand this way of doing things of what you call this deploying odd numbers of nodes.
-->
Right.
-->
But if you have an even number of nodes using arbiter to break ties.
-->
And then distribute nodes geographically deploy nodes in different data centers or regions to improve for tolerance.
-->
But considering that also you need to look at the networking between what you call this networking between those and then use priority settings to control which nodes can become primary.
-->
Configure read preferences.
-->
So use read preferences to distribute read operations.
-->
Primary, obviously default, but also use secondary or send all reads to secondary or send all reads to the nearest.
-->
Right.
-->
With the lowest network latency.
-->
And then monitor replication lag.
-->
It's very, very much important.
-->
MongoDB Atlas or RIS status, which is replica set status to monitor replication lag.
-->
And then ensure secondaries are keeping up with the primary to avoid tail reads.
-->
Enable authentication.
-->
When it comes to replication, use key file authentication or 509 certificates to secure communication between nodes.
-->
Ensure only authorized nodes can be able to join the replica set.
-->
Right.
-->
Test fail over regularly.
-->
It's very, very much important.
-->
Simulate a node failure and then use your RIS step down command to manually step down the primary for testing.
-->
Use write concern as we spoke about it, where one is acknowledged by the primary default, majority acknowledged by majority of nodes, and then two acknowledged by at least two nodes.
-->
Right.
-->
Always backup your data.
-->
Always make sure that you backup your data regularly and then upgrade to the latest version.
-->
As always, to take advantage of the latest features and bug fixes.
-->
Just a summary about it.
-->
The replica sets obviously provide high availability, some fault tolerance, data redundancy, MongoDB.
-->
And then there's the consistency of the primary nodes, secondary nodes and arbiter.
-->
And then best practice is using odd number for nodes and distributing nodes geographically.
-->
Configuring read preferences and testing fail over regularly.
-->
And then the replica sets are critical component of MongoDB architecture because then it helps in overall performance.
-->
And when you configure them, you need to be, you need to configure them and manage them carefully to be able to ensure optimal performance and reliability.
-->
Now some write concern, right?
-->
Let's talk about some write concern.
-->
Any questions on the replica?
-->
No question.
-->
Maybe just maybe this might be a question.
-->
So with databases, when you talk about replication and that concept of active, active, active, standby, active something.
-->
So in this case, do they have such a setup where you can run active, active, active, standby and so on?
-->
This setup, when it comes to replica sets, they are all active.
-->
The functionality is what differs.
-->
So your primary does the writing.
-->
So your inserts, your update, right?
-->
And then your replicas, right?
-->
Your secondary nodes do the reading.
-->
You can configure to do the reading.
-->
So they are all active in essence.
-->
The functionality is what's different.
-->
So in this case, you can have, you have five active servers.
-->
The functionality is what's different, right?
-->
There's that one where it's that situation where you've got a whole lot of replicas and one primary and many secondary.
-->
Then you can have a situation where you've got active and inactive.
-->
So you've got the active one, which you're doing everything basically.
-->
They read the write, right?
-->
And then you've got one secondary node probably.
-->
That's just there for replication purposes.
-->
You're not doing any read or any write on it, right?
-->
Then you have that active and non-active type of setup.
-->
But with replicas, right?
-->
Normally with replicas, they are all active.
-->
The difference is the functionality.
-->
The primary nodes does the write.
-->
And then you can configure the other secondary nodes to actually be the ones to do the read.
-->
OK, so but then the switch over, is it seamless, like it doesn't need manual intervention?
-->
When it comes to replicas, yes.
-->
The switch over is automatic.
-->
OK, so it will promote what was the secondary to become the primary.
-->
Yes, to become the primary, yes.
-->
So if it's got many, right, if you've got many secondary nodes, there's the election part, there's the priority part, right?
-->
So it could be done through the election part where the arbiter does the election to say, OK, this one is closer to the primary.
-->
And it's healthy, it's very healthy.
-->
Network latency is very good in terms of it and the application.
-->
This is based on, let's say, geographical location.
-->
So then it will elect that one or it will elect based on priority.
-->
Which one is the highest priority?
-->
You know, if it's priority one, then we're going to elect priority one, for example.
-->
But it's automatic, the failover is automatic.
-->
Oh, OK.
-->
Yeah.
-->
No, thanks.
-->
No worries.
-->
OK, some write concern.
-->
Where we said that we are sort of set, it's a setting that determines how MongoDB acknowledges your write operations.
-->
So you insert, you update, you delete, right?
-->
It specifies how many nodes must acknowledge the write.
-->
It then specifies whether the write must be journaled, written on the disk journal, which is very much recommended.
-->
And then by configuring this write concern, you ensure that the data is safely stored and replicated across nodes, right?
-->
Why is it important?
-->
There's durability.
-->
You ensure that the data is not lost in case of a failure, right?
-->
You make sure that it's only written when it's acknowledged by other nodes, right?
-->
There's consistency.
-->
So you're guaranteed that the data is replicated to the required number of nodes.
-->
And then there's the performance trade-offs, right?
-->
Where higher levels of write concern increase durability but may affect write performance.
-->
So you need to be mindful of that sort.
-->
The write concern levels, right?
-->
There's zero unacknowledged.
-->
So just write, you know, you don't need to acknowledge anything, right?
-->
Where these are in situations where it's just write and forget scenarios, right?
-->
Performance is critical.
-->
Data loss is acceptable, right?
-->
I wouldn't know what situation where data loss is acceptable.
-->
But yeah, you can have that situation.
-->
And then acknowledge one which means primary node just needs to acknowledge, right?
-->
So your general-purpose applications, you can be able to do that.
-->
And then when you have majority now, we are saying majority of the servers, right, of the replica set,
-->
if you've got 10 replicas, majority of them, 60 to 70 percent, 75 percent of them should acknowledge to have written the data, right?
-->
Which can cause issues, right, in regards to all this.
-->
Let me just pick up a call one second.
-->
It's an important call.
-->
All right.
-->
OK, I'm back.
-->
So that's your majority.
-->
And then you've got a situation where you can write the specified number of nodes to acknowledge.
-->
So in essence, if you want four to acknowledge out of the 20 or you want five to acknowledge out of the 20,
-->
then you can be able to give that.
-->
And then you also need to have journal, right, being active, being true.
-->
So journal being true is the J true.
-->
This would be obviously write is acknowledge only after it is written to the to the on-disk journal, right?
-->
That way, there's surety that data durability, it ensures that data durability, even in the case of a server crash.
-->
And then you've got your time out, which in essence means that if there is a time out, if it gives us time limit to the right operation to complete.
-->
Right.
-->
If the time out is reached, then the operation returns an error.
-->
So it's your right time out.
-->
Right. For example, in this case, it's insert one right concern should be should be acknowledged by two.
-->
But if there is a time out of five thousand seconds, then milliseconds, then seconds actually, then it should give an error.
-->
So how does the right concern work?
-->
Client sends right operation, right?
-->
Whether it's the application, whether it's the user or whatever.
-->
And then primary nodes process the right.
-->
So which means the primary node applies the right to its data set.
-->
And if J is specified, it also writes the right is also written to the journal.
-->
And then the primary nodes replicate the secondary nodes.
-->
Right.
-->
If then there are ten that needs to acknowledge, it then acknowledges that.
-->
And then only after that, only after it gets that acknowledgement, then the right is actually what you call this.
-->
The right is actually acknowledged and then sends a response to a client.
-->
Some best practices towards it.
-->
Choose the right right concern.
-->
Right.
-->
One for general purpose application, majority for high durability requirements or zero for non critical data that you don't really need to keep, you know, enable journaling.
-->
It's very, very much important.
-->
Set a reasonable time out and then monitor right performances.
-->
You need to monitor that and then test fail over scenarios and then use right concern with replica sets.
-->
It's very, very much good when you use the combination of two.
-->
Now, some replication failures.
-->
What are these replication failures?
-->
So replication failures can occur when the secondary nodes are unable to replicate from the primary node and which could lead to data inconsistencies, loss of availability, because now you can't automatically switch over.
-->
And even if the primary fails, right, the second is not up to date to even take over.
-->
Right.
-->
And then application may experience errors or degraded performances.
-->
Right.
-->
And then some common causes of replication failures could be network issue between the servers.
-->
Right.
-->
The nodes in themselves.
-->
Right.
-->
It could be high latency or some packet loss.
-->
Also could be hardware failures.
-->
It could be a disk failure.
-->
You know, several crashes or power outages could be another issue.
-->
And then configuration errors, incorrect replica set configuration and also and also mismatched MongoDB versions of
-->
configurations.
-->
And then some resource constraints could be insufficient CPU memory or disk or, you know, high right throughput causing replication lag.
-->
And then some upload issues.
-->
Right.
-->
Let's say the upload on the primary node is too small, which can cause it to override all the entries before secondaries can replicate them.
-->
And then some data corruption, you know, data corruption of the corruption of data files on the primary or secondary nodes could be another issue.
-->
Some diagnosis to to that check replica status.
-->
It's very much important.
-->
Look for the state of each node.
-->
The primary, the secondary recovering ETC replication leg up time date and last heartbeat fields can be able to tell you that.
-->
And then some error messages or warning and then monitor your replication leg.
-->
Also, other is the print secondary replication info to be able to check replication leg.
-->
Your high leg indicates that secondary is failing behind the falling behind the primary.
-->
So you need to probably restart your replica set so that it catches up or you need to stop the application from writing until they catch up.
-->
It just depends what you do.
-->
It's never advised to stop the application anyway, you know, and then check MongoDB logs.
-->
You need to examine your MongoDB log for any errors or warnings in relation to replication.
-->
These messages like your replication is too far behind or cannot replicate because up log is full.
-->
You need to be able to look for that and then verify network connectivity.
-->
Ping, Telnet, you know, test your connectivity between nodes.
-->
Your files or your security groups allow traffic on MongoDB.
-->
Make sure that they're open.
-->
They're OK.
-->
And then check disk and resource usage, your disk space usage, your CPU, your memory usage on all nodes.
-->
And then also your tools like your Mongo start, Mongo top can help you in terms of identifying resource, resource bottlenecks, right?
-->
Some resolving to it.
-->
Obviously, when there's a network issue, resolve some connectivity between the nodes, resolve any other issues if you need to make any changes.
-->
Adjust up log size.
-->
Up log size is very important.
-->
You need to be mindful of that.
-->
After you increase that, you restart the primary node and then resync affected secondaries.
-->
And then reconfigure replica set if you want.
-->
Ensure that it's configured properly using the RIS.conf to view the configuration, update anything using the RIS reconfig if needed.
-->
Then upgrade your MongoDB to the latest version, but the stable version, not just the latest version, but the stable version.
-->
And then monitor and optimize performance.
-->
Optimize your queries, use indexes to reduce write throughput, scale up hardware resources if necessary.
-->
Some how to prevent replication failures.
-->
Use odd number of nodes, right?
-->
Because then there's proper election and fault tolerance.
-->
And then monitor replication lag.
-->
Regularly backup your data.
-->
Test failovers regularly.
-->
Use write concern to ensure that data is replicated to multiple nodes.
-->
And then keep your MongoDB updated.
-->
Questions on replicas?
-->
Where is Akona today?
-->
They are too quiet.
-->
Oh, we are listening.
-->
Okay.
-->
Now let's talk about sharding.
-->
Sharding is the mechanism of distributing data across multiple servers, which are called shards, right?
-->
Where you then achieve that horizontal scaling, right?
-->
It automatically manages data distribution across shards, query routing to the appropriate shards, and then balancing data evenly across shards, right?
-->
Why use sharding?
-->
It handles large data sets and high read write throughput, right?
-->
There's that scalability.
-->
And then performance-wise, it distributes load across multiple servers.
-->
And then it can store more data than a single server can handle, right?
-->
How do they work?
-->
So the key components of it is a shard.
-->
So each shard is a replica set or a standalone MongoDB instance, where it stores a subset of data, right?
-->
For an example's purposes, shard one stores data users A to M, shard two then stores N to Z, right?
-->
It's also got a config server where metadata is stored about the cluster, including the mapping of the data to the shards, right?
-->
Must be deployed as a replica set for higher availability.
-->
And then it's also got logical query routers, obviously that sort of interface that acts as an interface between the application and the shard cluster, right?
-->
So that's queries to the appropriate shard based on the shared key, on the shard key.
-->
And then what is a shard key?
-->
A shard key is more or less a field or a set of fields used to distribute, what do you call this, used to distribute data across shards, right?
-->
So let's say your shard key is a user ID, which means MongoDB ashes the user ID value to determine which shard should store the document, right?
-->
And then there's also that data distribution where it's a range based or hashed sharding strategy to distribute the data.
-->
So when it's range based, data is divided into ranges based on the shared key, right?
-->
And then hashed sharding is data is distributed using a hash of the shared key, right?
-->
Then there's also the part of query routing, where when a query is sent to the cluster, right?
-->
The MongoS router determines which shards contain the relevant data, and then the query is routed to the appropriate shard, right?
-->
And the results are combined and returned to the client, and then it does what you call balancing.
-->
There's what you call a balancer that automatically balances data across the shards.
-->
And then this balancer moves chunks, subsets of data between shards to ensure even distribution, right?
-->
How do you then set up a shard cluster, right?
-->
First, you set up the config server. So you deploy a replica set for the config server.
-->
For example, there in blue, you've got sharding, cluster role is the config server, and then replication set name is config replica set.
-->
Config being the config server, replica set, and then you set up shards.
-->
So you deploy replica sets for each shard, and then an example is you call cluster role is the shard server, right?
-->
And then replication, you name it shard one replica set, and then you can be able to add replicas to a replica set, right?
-->
So you start your query routers, start MongoS instances, and configure them to connect automatically.
-->
For examples purposes, MongoS configure DB, the config set, configure replica set, config one, and then config two, and then config three as you go,
-->
which is more or less, this is you connecting your configuration replica, and then you add shards to the cluster, right?
-->
So connect to MongoS instance and add shards to the cluster. For example, add shards, sh.shard, shard one replica set,
-->
shard one A, shard one B, shard one C, and they connect using that port.
-->
And then shard two replica sets, shard two A, shard two B, this is how you can be able to add those shards to the cluster, right?
-->
And then enable sharding for a database where you enable sharding my database to a specific database, and then you can be able to shard the collection.
-->
So you can also shard the collection, right, where you've got shard collection, and then my database dot my collection user ID one, and then some best practices for sharding.
-->
You need to choose the right shard key. You need to have a high cardinality, many unique values type of key, and then distribute rights evenly across shards,
-->
and then also support your most common queries. So your key should be able to support your most common queries.
-->
As I gave an example, when you get into the bank, the very first thing they ask you is your ID. Your ID will be able to pull everything.
-->
So things like that, you can be able to have it as a shard key, right? And then monitor and balance the cluster.
-->
If you use things like MongoDB Atlas or SxStatus, right, shard status, you can then be able to monitor a cluster and then ensure the balancer is running and data is evenly distributed.
-->
Use hashed sharding for even distribution, right? And your shared key has low cardinality or is monotonically increasing.
-->
So use hashed sharding to distribute data more evenly and then avoid hotspots. And hotspots is an even distribution of rights and plan for growth.
-->
Plan that you are going to add more shards because there's going to be more data coming through.
-->
You probably need to add more shards and then back up and secure your cluster and then test before production. It's very much important.
-->
How do you choose a shard key, right? It's a very critical component of it, right?
-->
And shard key, as we said, is a field or a set of fields in a document that MongoDB uses to distribute data across shards, right?
-->
You could use user ID and then when you select user ID, then it's going to use the user ID value to determine which shard should store the document.
-->
So if you've got 10 shards and your user ID is incremental, then it will be able to determine where to place which document.
-->
Some characteristics of a good shard is high cardinality. So it should have unique values, right?
-->
Unique values to ensure that there is that even distribution. An example being user ID because it has many unique values, right?
-->
Even distribution, the shard key should distribute writes and reads evenly across shards, right?
-->
It avoids keys that create hotspots and then query support so it's able to assist with queries.
-->
And then, for example, if most queries filter by region, use region as part of the shard key, right?
-->
The shard key. Immutable, right? It cannot be changed after sharding a collection, so you can't change that after sharding a collection.
-->
So you need to choose a field that will not change over time. That's very, very important to the system.
-->
And then some type of shard keys. We've got single field shard key, for example, user ID, right?
-->
It's simple and then there's compound one, which is region one and user ID where you provide like a compound shard key.
-->
It's like a compound indexing and then there's the hashed shard key where you hash the user ID, right?
-->
And then choose an example for a collection of user data. You can use user ID and then for a collection of orders, you can then compound shard key, right?
-->
It could be order date, region, it could be user, whatever, right? And then sharding and indexes play a very critical role, right?
-->
In optimizing queries. Now, shard key index, right? So MongoDB also requires an index on the shard key, right?
-->
You can actually index that. If no index exists, MongoDB creates one automatically when you shard the collection.
-->
So it's that type of scenario where it says I really need this shard key to be indexed. If you don't index it, I'll index it on my own.
-->
And then if you're using compound shard key, ensure the index matches the shard key.
-->
So like previously, I did email and age, right, as indexes. Then I need to make sure that my shard key also are email and age, right?
-->
It helps a lot. And then it helps in terms of query performances. Queries that include the shard key are added to specific shards, which is very good for performance.
-->
And queries that do not include the shard key are broadcast to all shards, which can make it slower, right?
-->
The same way with index. When data doesn't have an index or when you don't have an index, it needs to go through a whole collection.
-->
When it's got an index, then it just goes straight to the index and that's it, right?
-->
Some best practices is create indexes on fields commonly used in queries the same way you use shards.
-->
Shards use them commonly, the fields that are commonly used in queries and then all the data that's commonly requested or queried.
-->
And then use covered queries, queries that use only indexed fields to improve performance.
-->
Then you've got sharding and replica set topologies, right?
-->
They are often used together, right? Not often they are used together, right?
-->
There you've got scalability, you've got high availability, you've got improved performances, right?
-->
And you're going to also have shard as a replica set. When I was showing the configuration here, right?
-->
It actually had a replica set. It's got shard as a replica set, right?
-->
So each shard in a sharded cluster is typically a replica set.
-->
And this obviously ensures high availability and full tolerance for each shard.
-->
And then when you have a config server as a replica set, it means that your metadata is distributed.
-->
And that way config server that store metadata about the shard server must be deployed as a replica set for high availability, right?
-->
You've got that high availability where when one crashes, the primary crashes, then you've got the secondary.
-->
And then also have query routers where Mongo instances are stateless and can be deployed on multiple servers for scalability and redundancy.
-->
That's your Mongo S. And then an example of a topologies having shards which are three replica sets, shard one, shard two, shard three.
-->
And you've got config servers, which is one replica set, which has got three nodes.
-->
And then you've got query routers, which is three Mongo instances, right?
-->
That's an example topology that you can be able to have in place.
-->
Now, how do you administer sharded clusters, right?
-->
Firstly, you monitor using your MongoDB Atlas, right?
-->
You monitor, you balance, you optimize performances.
-->
And the monitoring part, you can use your MongoDB Atlas or MongoStat to monitor the cluster.
-->
The key metrics to look out for there is your replication lag.
-->
Is it falling behind?
-->
And then your shard balancing. Is it balancing it right?
-->
And then your query performances, right?
-->
Are they slow? Are the query performance slow, right?
-->
You also need to balance your cluster, right?
-->
Using a balancer. So you can disable the balancer for a collection.
-->
You can also be able to start a balancer manually.
-->
So for example, they disable balancing for my collection.
-->
So your database name is university and your collection is students.
-->
You can disable that.
-->
You can also manually start or stop the balancer.
-->
And then you can also be able to add or remove shards.
-->
So for example, the shard replica set is shard replica set one.
-->
That's the name of the replica set.
-->
And then you want to add the host and port.
-->
So you want to add the new host or you want to remove a host, right?
-->
So you can have that sh shard dot sh dot remove shard.
-->
And then the name of the replica set and then the host that you want to remove, right?
-->
It's also important to do some backing up and restoring.
-->
Very much important.
-->
And then enable authentication and encryption to secure your cluster.
-->
Use role-based access control and then upgrade your cluster.
-->
It's very much important.
-->
But you need to follow the MongoDB upgrade instructions to upgrade your shared cluster.
-->
It's very, very much important.
-->
And then ensure all components, your shards, your config servers, and mongos are upgraded in correct order based on what MongoDB would be instructing you to do.
-->
Questions?
-->
No question from me.
-->
Anyone else?
-->
Silence means we are good.
-->
OK.
-->
Now let's talk about shard chunk migration.
-->
And so shard chunk migration is a key feature of MongoDB, right?
-->
And it ensures that data is evenly distributed across shards, right?
-->
What is a chunk?
-->
A chunk is a subset of data, right, in a shard collection.
-->
And what MongoDB does is it divides data into chunks based on the shard key.
-->
And each chunk is assigned to a specific shard, right?
-->
Why does chunk migration happen, right, for balancing purposes, for example, right, between shards?
-->
It wants to have that even distribution or when there's that manual intervention where administrators can actually move chunks for maintenance or optimization.
-->
That's another reason why chunks can be migrated.
-->
And how do chunks, chunk migration work?
-->
How does it work, right?
-->
There is the balancer.
-->
The balancer monitors the distribution of chunk across shards, right?
-->
The shard has significantly more chunks than the other.
-->
The balancer initiates the chunk migration to one that it needs to level up.
-->
And then the migration process behind it is the source shard copies the chunk to the destination shard.
-->
The destination shard applies any changes that occurred during the migration and then the config server updates the metadata to reflect the new location of the chunk, right?
-->
And then upon completion, once the migration is completed, the chunk is removed from the source shard.
-->
So it makes sure that everything is good and it's updated in the config server and then it removes from the source.
-->
Some backup and restore plans.
-->
Backup and restore plans.
-->
Some backup strategies that are available.
-->
File based backup.
-->
So you can take snapshots of your MongoDB data files, right?
-->
And then this one is suitable for large data sets with minimal downtime.
-->
So you can use things like AdaSync or whatever.
-->
Or you can use snapshot, KVM snapshot if you're using KVM.
-->
And then you can do logical backups where you can use Mongo dump where you can export data in BSON to JSON format.
-->
This one is suitable for smaller data sets or specific collections.
-->
And then you can also have cloud based backup, right?
-->
Your MongoDB Atlas or other cloud services for automated backups.
-->
And then restore strategies.
-->
You can restore data from a file system snapshot.
-->
You can do logical restores.
-->
So if you do MongoDB, you can then do Mongo restore to import that data and then restore data from cloud backups.
-->
That's another option that you can be able to use.
-->
So some file based, file system based strategies, right?
-->
Some steps to it.
-->
So, for example, taking a snapshot of MongoDB data files.
-->
So first thing you need to do is stop the MongoDB instance or lock the database, right?
-->
Take a snapshot of the data using tools like your LVM, your AWS EBS snapshots, you know, or whatever you're using.
-->
And then after it's done, you unlock the database, right?
-->
And then some steps for file system based restore.
-->
Stop the MongoDB instance.
-->
Replace the data files with the snapshot.
-->
And then start the MongoDB instance.
-->
Be mindful that you need to place your data files in the path that is configured within your MongoDB config file, right?
-->
It's very much important.
-->
Some best practices to it.
-->
Obviously test regularly to ensure that they can be restored and then use journaling to ensure that the data is consistent during backups.
-->
Then when you also use MongoDB and MongoDump and MongoRestore, right?
-->
MongoDump being, for example, there you've got MongoDump.
-->
Your host is your local host, the port, and then the out backup.
-->
I think we did this yesterday.
-->
And then you can just replace the MongoDump command with the MongoRestore.
-->
Same, everything else stays the same.
-->
It's just from MongoDB change it to MongoRestore.
-->
And then some best practices to it.
-->
Use the up log with MongoDB, no MongoDump, sorry, to capture ongoing changes during the backup.
-->
And then compress the backups to save space.
-->
So you can use the dash dash jzip, right?
-->
When you're using the dash dash, when you're using the up log, it's a matter of just adding dash dash up log onto it, onto the command.
-->
You can also be able to use Arasync, right?
-->
Arasync, where you make copies of data files to a backup location.
-->
It could be to a remote location or to another folder, for example.
-->
You can be able to use Arasync.
-->
And then best practices is using Arasync with delete to remove the files in the destination that no longer exist in the source.
-->
Right.
-->
So updating wise, use the dash dash delete, which then tells Arasync to be able to get to the destination and be able to check.
-->
If it's not from the source, if it's not available in the source, then make sure it is deleted in the destination also.
-->
There's also MongoImport and MongoExport.
-->
MongoExport is where you export data from a collection to a JSON or CSV file.
-->
So, for example, there you've got your MongoExport dash dash host localhost port.
-->
You are doing my database.
-->
It could be university in our case.
-->
And then your collection is students.
-->
And then you are putting it in a backup folder and you're making it my collection.JSON.
-->
And then when you then need to import, it's a matter of making sure that you just change from MongoExport to MongoImport.
-->
And then more or less, the rest of the stuff is the same.
-->
It will just do the reversal.
-->
Any questions?
-->
Okay, cool.
-->
We're probably going to finish the theory part and then we go into our tea break.
-->
And then from our tea break, we come and then do the practicals.
-->
Then it will take us through the rest of the day.
-->
So some best practices for your backup and restore.
-->
Use dash dash type to specify the file format and then use dash dash fields to export specific fields.
-->
And then some summary to that.
-->
Shard and chunk migration.
-->
It ensures that even distribution of data across shards, you can use the balancer or you can manually move chunks.
-->
Backup and restore plans.
-->
You can use the file based strategies.
-->
You can use the MongoDump, MongoRestore.
-->
You could use what you call this cloud based backup.
-->
And then you've got your MongoDB, MongoDump or MongoRestore.
-->
Obviously for export and import data.
-->
And then file based, file system based strategies.
-->
Taking snapshots of your MongoDB data files or light sets.
-->
And then you've got Arasync also where you can synchronize MongoDB data files for backups.
-->
And then you can also use the Mongo import and export, right?
-->
Exporting it into or importing it.
-->
Exporting or importing in JSON or CSV format.
-->
Obviously for specific collections.
-->
It just depends what is it that you want to be able to do.
-->
Now that's the theory part about today.
-->
Any questions in terms of today and yesterday?
-->
The theory part before then we go into the practical part of it.
-->
Okay.
-->
Silent says we are good.
-->
It's 21 past.
-->
We can take now and be back at quarter two from our tea break.
-->
And then we'll continue from number six on the practical stuff.
-->
All right. Thanks.
-->
Happy with that?
-->
Awesome stuff.
-->
All right.
-->
He's already good.
-->
Yeah.
-->
Thanks.
-->
It's good.
-->
So are you saying?
-->
I'm not saying people will just come to see me.
-->
People will just come to see me.
-->
We will just meet up and whatever happens happens.
-->
Then you get many from that.
-->
Yeah.
-->
But I want to put it like this, right?
-->
Where's the camera?
-->
I want to look at the camera.
-->
I actually just want to make it clear that a lot of people actually think this is like prostitution.
-->
No, but it's actually knowing the value.
-->
So you smash for cash?
-->
Yes, but it's not prostitution, sir.
-->
Wait, wait, wait.
-->
I'm a bit confused.
-->
I'll tell you why.
-->
It's like maybe I don't know the tasteful definition.
-->
Yeah.
-->
And that's all.
-->
And that's all.
-->
And that's all.
-->
I think that's the end of the talk.
-->
There was a fight on our desk about a very senior politician.
-->
And as a result, they deployed all the state resources to counter it.
-->
And that's why I was sitting at home for a year.
-->
So that was not a surprise.
-->
South Africans are forgotten.
-->
They sit at home without doing anything.
-->
Simple because I dealt with the rogue enemies in the organization, which then irritated some politicians.
-->
And then I'm happy to say today, some of the rogue enemies we're dealing with in the police are not in the service anymore.
-->
Some of them, senior people, are sitting in prison that we're dealing with back then in 2011.
-->
But when we're doing that, we were handcuffed.
-->
We're the bad ones.
-->
Simple because we charged the wrong people.
-->
So we did not surrender then.
-->
We're not going to surrender now.
-->
So we see that we're on paper.
-->
We do it on paper.
-->
We'll find each other in court.
-->
You'll come down with whatever.
-->
You'll come down with I'm not going to do any media things.
-->
They end up with whatever they like.
-->
I've been there for so many years.
-->
You know, I've been bruised.
-->
So this this doesn't scare me.
-->
And I'm not going to waste my breath in dealing with people that are faceless.
-->
But for those that are within the system that are doing things wrong, we're going to challenge them legally and deal with them.
-->
But if they want to come physical, we'll find each other in the field.
-->
That's just part of it.
-->
I've been in over there.
-->
So we have another beautiful lady over here.
-->
Hi.
-->
What's your name?
-->
Hi, how are you? I'm Tasha Cubes.
-->
Oh, Tasha Cubes.
-->
Nice to meet you.
-->
So a couple of questions.
-->
If we were to offer you a 10K EFT or 500 E-Wallet, what would you choose?
-->
500 E-Wallet.
-->
What would you do with it?
-->
500 E-Wallet.
-->
Just something quick.
-->
I'll just take myself out.
-->
I won't lie.
-->
I'll just take myself out just to go buy E-Wallet.
-->
Solo date bags.
-->
Okay.
-->
Yeah.
-->
Okay.
-->
I'll fill you.
-->
So we have another beautiful lady over here.
-->
Hi.
-->
Hi.
-->
I need your guys' help.
-->
What?
-->
Hi, how are you?
-->
I'm beautiful, thank you.
-->
Hi.
-->
Let's ask them about 291.
-->
Happy Office.
-->
Yeah.
-->
Thank you.
-->
Go ahead.
-->
So a couple of questions.
-->
to separate your business dealings with your personal affairs. If you are running a business or you are an emerging entrepreneur, if you are doing a start-up, ensure that you separate your business matters to your personal matters.
-->
Don't mix up the expenses, don't pay, don't mess up using the business money, make sure it's distinguishable between yourself and the legal entity, which is your business.
-->
We find this to be a problem amongst most of our clients that are having start-ups or they are running sole proprietorship businesses where they are the sole trader and so forth.
-->
And some of them we find them paying medical aid using the company and they are paying for the apparels and so forth, which are not employees of the company.
-->
And it becomes difficult then to comply with such, a lot of them we find them to be non-compliant and we have to do VDPs and try to help them with their compliance. So it's just an edge to most taxpayers just to keep that distinction clear.
-->
Guys, it's 2025. We can't keep having the same conversation about video call etiquette. You can't open your WhatsApp or open your FaceTime app and type someone's name that you are not used to in that way, that you don't have that relationship with.
-->
Maybe when that person talks like once or twice a month, you type their name and you paste that little video button and call them without even giving them a heads up. Something as simple as just before you're going to call the same way, are you free, can you take a call?
-->
Can I video call you? Let me know when you can take a video call. Let me know when you can take a call. Simple. I look at my phone, I stare at my phone, I just stare at my phone like this because why are you just...
-->
I look at some of the funny moments he initiated in the house.
-->
Dr. Ngozi is one of the politicians that has a popularity appeal across the political spectrum. His personality earned him the title.
-->
Just imagine how good...
-->
Do you guys ever dated scammers? Like, okay, not like scammers, like...
-->
Okay.
-->
I watched Harry Potter, had this cocktail, I had this chocolate green plate, it was too good, and then guys, my brain fell and I was just like so sad. I watched Frenchy show and had some bubbles and after playing for almost 20 hours, we finally made it.
-->
And can I have a batini?
-->
So this is video number two, number one.
-->
I want to kill it.
-->
I want to kill it.
-->
I want to kill it.
-->
I want to kill it.
-->
I want to kill it.
-->
I'm seeing a lot of people using curser at the moment.
-->
Like, I cheated.
-->
Because I've already fucking been cheating seven times.
-->
Story time, you guys. I did.
-->
Okay, are we back?
-->
Okay, cool.
-->
I just need to log into my...