Where and how to instantiate dependencies - php

Question

I'm trying really hard to understand Dependency Injection and how to avoid globals, within the scope of the backend of a website project. Here I'm using PHP.
// MySQLDatabase.php
class MySQLDatabase
{
private $database;
public function __construct($db_host, $db_username, $db_password, $db_name) {
$this->database = new mysqli(
$db_host,
$db_username,
$db_password,
$db_name
);
}
}
// User.php
class User {
public function __construct($database, $id);
}
// Image.php
class Image {
public function __construct($database, $id);
}
$database = new MySQLDatabase($dbh, $dbu, $dbp, $dbn);
$existingUser = new User($database, $userID);
$existingImage = new Image($database, $imageID);
I understand that in order to keep the code testable, contained, and without globals, I need to inject dependencies. Where I'm confused is where to instantiate these dependencies. Seems like every question about dependency injection is answered with the above code, and they say "That's how you do it!" But they never explain how to set up the rest of your program so that dependencies can be hooked together.
I first thought of using a bootstrap file which instantiates the dependencies first for the rest of the program to use:
// bootstrap.php
$database = new MySQLDatabase($dbh, $dbu, $dbp, $dbn);
But this to me seems like I'm just creating a global here. Almost every one of my pages would need the database, and this database here would get passed around every script... Seems like a singleton to me (which everyone also says to avoid).
I could instantiate the database anywhere that I need it, on a page to page basis. This would mean the user.php page wouldn't use a bootstrap file, and just pull the dependencies it needs (database, user classes, etc). And this would happen on every page (user_images.php, login.php). But this seems like code repetition, because every page would have some of the same code. I've also thought about making a static-type class that makes it easier to instantiate the database, which you can load through a file:
// MySQLDatabase.php
class SpecificDatabase
{
private static $initialized = false;
public static function initialize($db_host, $db_username, $db_password, $db_name) {
if(self::$initialized) return;
self::$database = new MySQLDatabase(
$db_host,
$db_username,
$db_password,
$db_name
);
self::$initialized = true;
}
}
But in this case you would always have to get the db credentials to initialize the database every time you wanted to use it (unless you hard-coded it here, but I think that's just as bad). So littered throughout my code on almost every page would be the following:
require_once(__DIR__.'/vendor/autoload.php');
require_once(__DIR__.'/utilities/database/SpecificDatabase.php');
require_once(__DIR__.'/entities/User.php');
// load environment variables
$dotenv = new Dotenv\Dotenv(__DIR__);
$dotenv->load();
$database = new SpecificDatabase(getenv('DATABASE_HOST'), getenv('DATABASE_USERNAME'), getenv('DATABASE_PASSWORD'), getenv('DATABASE_NAME'));
$user = new User($database, $userID);
Could someone help me understand this better? I really want to be a great programmer. There are just some hurdles that are taking me a lot longer to understand, and I think it might come down to some simple misunderstandings, especially vocabulary - for example, I think I am blocked by the paradox of avoiding repetition AND avoiding globals. Most of my study of dependency injection comes to the conclusion of pulling dependencies out from inside classes. But when they get pulled out, where do they go...?