How does the stack cleanup work in assembly functions?

I'm trying to get a better grasp on how the stack is managed during function calls in assembly, particularly concerning cleanup after a function executes. For instance, when `main` calls `myFunction`, the stack behaves in a specific manner. Here's the structure I have in mind:

```
myFunction:
push %rbp
mov %rsp, %rbp
sub %rsp, 16 ; Allocate space for local variables

; Local variables are used here

; Cleanup begins
mov %rbp, %rsp ; Free up local variable space
pop %rbp
ret
```

When `myFunction` is called, it pushes the return address to `main` onto the stack. I have a couple of questions:

1. Why is `push %rbp` necessary after this? What does it contribute?
2. When `pop %rbp` is executed, I know `%rsp` is increased by 8, but what changes happen behind the scenes? Is there more to it than just moving the pointer?

I think the stack looks like this when the stack pointer and base pointer are set:

```
local variable space <- rsp and rbp point here before pop
main %rbp
return address to main
```

After popping, effective `%rsp` points to the previous `%rbp` from `main`, but isn't that just a number? How does the process know where to go back to? And what about `%rbp` once control is returned?