Mysql docker mac os

Setting up Database Servers for Development on Mac OS X Using Docker

If you are beginning your software development career and using Mac, and interested in using relational databases like MySQL/MariaDB, PostgreSQL, Microsoft SQL Server, Azure CosmosDB SQL or Oracle Database, then this article is for you!

If you like this article, please clap for it! Click on the little hands icon to the left or bottom of this page.

Now, in the past when I used to run Linux on my laptops, I’d just install each database directly into my environment. Sometimes I’d face problems like dependency-hell, conflicts, native libraries missing, and would eventually end up running the databases in isolated VirtualBox VMs. In today’s containerized world, this is past.

If you really want to make your own developer life easier, get used to Docker and spin up databases in containers. All of them.

Running RDBMS in containers may not be suited for production, but for development/testing environments? It is the perfect fit.

If you haven’t already done it, make sure you install Homebrew and Cask — package managers for Mac OS. Not only for this article but pretty much for everything you will eventually install in the future.

Pre-requisites

You will have to install Docker. And while Kitematic is optional, I actually recommend you do so. Easier to manage the containers in your system once you create them (start/stop/restart/delete).

Once you have Docker installed, make sure you have an account in the Docker Store — sign-up here. That will be needed for some of the databases. Once you have your account, log in to it either in the UI or with docker login.

CLIs for Database Clients

To connect to a database, you will need a client, and ideally one that you can quickly use through the command-line/terminal. For each database below you will find two instructions: one to install and start the database using Docker, and one to install and connect to that database using a CLI.

Most databases provide Client CLI within the Docker image, but I find it extremely useful to have these clients installed so you can easily connect to databases running elsewhere, such as in the Cloud, or remote in some server in your intranet. Plus, you can also automate stuff writing scripts.

Not that you can’t do these things with CLI inside Docker… It’s just my preference.

Getting Started

All four major databases provide Docker images these days. And I was closely involved in the build up of the Docker image for the Oracle Database, gracefully put together by my friend Gerald Venzl. But the other databases provide very useful and well-assembled Docker images too, and I am sure you will appreciate them all.

MySQL

There are two MySQL images on Docker Hub you should be aware of:

I always prefer to use products through tools officially provided by the maker of that product. Feel free to try [2], but below are instructions for Oracle’s MySQL Server.

Download and start MySQL container:

Note the use of special environment variables. Check the documentation of this image for more information and other options such as how to connect with root.

Install MySQL Shell and connect to the database:

Microsoft SQL Server

Microsoft has been doing pretty cool stuff in recent years. Not only they have made this product available for Linux, they now also offer pretty good Docker images for it.

Download and start Microsoft SQL Server container:

Install and connect using sqlcmd — more details here.

Connect to SQL Server:

PostgreSQL

This image is provided and supported by the PostgreSQL Docker Community. Basically people at Docker and also folks who are involved in PostgreSQL development. I found this image to also be very straightforward and simple to use.

Download and run PostgreSQL:

Install and connect using PSQL:

Azure CosmosDB

CosmosDB is an interesting Microsoft Azure’s service that allows developers to use different APIs to connect to the same datastore. For example, you can use CosmosDB as a drop-in replacement for MongoDB, or Cassandra. It also provides a SQL API. You just point an existing application previously developed for one of these databases on CosmosDB, and it will just work (well, give it or take). It also scales beautifully. Even Thomson Reuters is using it.

The easiest way to use CosmosDB is again, IMO, through the command line. But to play with it of course you will first need an Azure account. Besides giving some few hundreds of dollars for you to use in your first 30 days, Microsoft Azure also has many services that are always free (to certain limits/quotas), and some services that are free in your first 12 months, if you activate your subscription during or after the first 30 days.

So, go to azure.microsoft.com/free right now and create an account.

Install the Azure CLI. For Mac OS X you just use Homebrew:

For Linux, check the documentation which contains instructions for different package managers and distributions.

And if you do decide to play with it, just follow this » Create an SQL API account using CLI» sample!

Oracle Database

During my time at Oracle, I led the company’s presence on GitHub, helping teams structure their projects, and also launch newly open sourced libraries, tools, resources, and samples sets. There was, though, one particular project I was taking care of since the beginning: the docker-images repository. And I am extremely proud of the advancements and improvements of developer experience for some key Oracle products that we were able to deliver thanks to Docker and the amazing work from folks like Monica Riccelli, Avi Miller, Gerald Venzl and many other engineers and product managers.

In the past it used to be quite frustrating to install and run Oracle Database for development purposes, but thanks to Gerald and Docker, it is now as simple as it can get.

Now, while anyone can go to the docker-images repository, download Dockerfiles and build their own images for the commercial products, in fact there are some pre-built images available for common products on the Docker Store and also on the Oracle Container Registry server.

Below I outline the steps required fordownloading and running an Oracle Database image from the Docker Store.

At this point I will assume you already have a Docker ID (account). If you don’t, create one.

— Go to the Oracle Database image page on Docker Store
— Click on Proceed to Checkout (blue button to the right)

Источник

Jason McCreary I build things with my hands

Main Thread September 5, 2020 • 14 min read

I know, Docker, gross right? Suppress that reaction for a few paragraphs…

For the last 8 years I’ve held one of the top search results for Installing Apache, PHP, and MySQL on Mac OS X. It wasn’t until installing macOS Catalina that I began to move away from the preinstalled development tools I had preached for so many years.

The primary reason was the need for a newer version of PHP. I held hope the next version of macOS might adopt a modern version of PHP. However, it looks like macOS Big Sur will not upgrade PHP. In fact, Apple has added a warning about using the preinstalled PHP version and plans to no longer include it in future versions of macOS. All of which set the internet ablaze. Which 75% of is powered by PHP.

For those reasons, I am finally making the switch to using Docker for local development with Apache, MySQL, and PHP on macOS. This post will outline the process for a basic setup using Docker.

Before moving on to the actual implementation, let me address the two questions I still receive after all these years.

1. Why not use Homebrew?
2. Why use Docker?

Homebrew is a package manager for macOS. And when it works, it works. But when it doesn’t you’re going to burn a day searching the web trying to figure out some obscure error message. And you may get it working again. But it’s only a matter of time until you receive another obscure error and burn another day. And when you upgrade macOS, you’ll receive another error and the solutions before no longer work.

Yes yes, I know you don’t have any problems. But it’s happened to me enough times over multiple versions and multiple years. I’ve given it a chance. I don’t want to waste anymore time on it.

If I’m going to spend days learning something, I’d rather learn something which brings value beyond a single purpose. Something I can use elsewhere or again, beyond my Mac. And Docker can be used for so much more than local development on macOS.

In fairness, I tried using Docker multiple times before. Similar to Homebrew I’d run into issues. But I didn’t really give it a chance. In addition, Docker has made advancements since I tried over the years. Most notably having a default client for most platforms, including macOS and Windows.

The reality is, Docker is a simple client install and then a couple commands from the command line. Once using Docker, you have access to countless images to create all sorts of development environments, running things beyond Apache, MySQL, and PHP. You can set up a complete infrastructure which perfectly mimics your production environment running load balances, cache servers, queue workers, and more.

So, to address the matter simply — if I’m going to learn something I want to get the most return on my time investment. These days, I think learning a ubiquitous tool like Docker provides a far better return on my investment than learning how to wrangle a package manager on my local macOS.

Yes I know there’s MAMP, Valet, and whatever other hotness. But they all run Homebrew underneath. With Docker I can take my image and provision local development environment, a production environment, a GitHub action, and so much more.

With that said, let’s move on to getting a local development environment running Apache, PHP, MySQL on your Mac using Docker.

Installing Docker

Since this is a tutorial for macOS, download the Docker Desktop for Mac.

However, if you are using another platform, such as Windows, you may still follow along with this tutorial. That’s another benefit of Docker. Once you have Docker installed locally, you can run anything you want.

Creating an image

With Docker installed locally, we need to tell Docker what type of server we want to run. We do this with an image file. Yes, I’m taking a few liberties with those terms.

There are all sorts of images available. As you become more proficient with Docker you can find (or create) one to better suit your application needs.

The one I’m offering web server running PHP and Apache. This effectively replaces the technologies which were originally installed on macOS by default.

Here are the specs for this image:

In addition, this includes the latest version of Composer (2.0) and Git.

All this goes in a Dockerfile . Here’s the one we’ll be using:

You are welcome to copy the file above. However, it would be better to download my local-docker-stack repo as it will contain all the files we’ll use within this tutorial.

I like to put this in my workspace as I share this image across all my projects. But if you have a single project or specific requirement, you’re welcome to put this Dockerfile directly within your project folder.

What about MySQL?

Similar to the way we installed Apache, MySQL, and PHP on macOS, we will install MySQL separately. In this case, we’ll pull in the latest official image for MySQL 8.0. Then we’ll run these two side-by-side — more on that in a bit.

Building the Docker image

Now that we have an image we may turn this into a runnable server by running:

Before dissecting the command itself, let’s talk a little bit about what it does.

Running this command will generate an executable version of our image. It builds a server if you will. Something we may run and interact with. This is what Docker calls a container.

Looking at the command we pass it the path to a Dockerfile. In this case, the images/Dockerfile-php-apache from within local-docker-stack repo. However, you may change this to wherever you store this Dockerfile.

We also set the -t option to gives our container a name. This makes it easier to identify when we run other Docker commands later.

Running the

Now that built our image into a container, we can run an instance of this container with the following command:

With any luck this should spin up our web server running Apache and PHP in the background using the -d option. We can verify this by running the following Docker command:

Since we mapped web port 80 with the -p option, we should also be able to open a browser and visit http://127.0.0.1/. You probably see an Apache error page. But hey, it’s a start.

Interacting with the server

Cool. Our server is running. For the most part, you can carry on developing as normal and interact with the server via the browser.

However, at some point you’ll need to interact with the server directly. So using the same command above we can get a reference to the specific running container instance. This was the ID column from the command we just ran.

So let’s run it again:

It will output something like the following:

We want the value from the ID column. In this example, it’s 96b0239fafa9 .

Using that we can pass that to the Docker exec command to get an interactive terminal by running:

Let’s take a sec to dissect this command. It allows us to run an interactive terminal within the container instance we specified using the Bash shell.

Of course, you could build an image with whatever shell you like. But again since macOS defaults to Bash, that’s what I’m using here.

Let’s throw a few commands at it like php -v to see the PHP version and composer -V to see the Composer version. Then we’ll exit the terminal with exit or by pressing Ctrl + D .

What’s nice is this environment can mirror your production environment. It ideally has the same paths, operating system, software, and versions your production server has. So Docker simulates your actual application environment versus running Apache, PHP, and MySQL locally on macOS would have.

What’s not nice about this, is the same thing that’s not nice about Docker. It can be slow. You may notice a file system lag when interacting with files or installing things locally. For example, a file intensive command like composer install . Or even worse, npm install .

For those reasons, whenever possible I may still run these commands locally. Especially npm install as that may require system level components which are easier to install locally than on the container.

Fortunately such operations are not that common. So I’ve learned to live with it. Use the opportunity to take a break, stretch, or check email.

Alright, before moving on let’s stop this container by running:

Mapping local files

Since we are editing files locally, we’ll want to map these files to these Docker containers. We may do so by using volumes. These share the local filesystem with the Docker filesystem.

In this case, I want to share my workspace. This is the folder where I store all my web projects. For me it’s

/workspace . For you it can be anywhere you want. Just be sure to replace it with your path in the following references.

We’ll also want to make a folder that will store the MySQL data. To do that we can run the following command.

Again, you are welcome to change this path just update any references accordingly.

Setting up the volumes

We’re going to jump ahead just a bit and map these two external volumes for Docker which we’ll use in the next section.

The following commands will create a volume named workspace mapping to /Users/jasonmccreary/workspace and a volume named data mapping to /Users/jasonmccreary/data . We may then reference these volumes by name instead of always typing their paths. Again, please change the paths accordingly.

Running the full LAMP stack

So far we’ve only run our web server. We haven’t run the MySQL server. We need to have our complete Apache, MySQL, PHP stack running if we’re going to develop locally on macOS.

We could do this with multiple docker run commands. Passing the -d option to run in the background, along with multiple options such a -p to map the ports and -v to set up the volumes. But that would be annoying.

Instead, we can define our stack with a Docker Compose file. Essentially this file defines all the same options we would pass to docker run , but in a single place. This not only provides us with a full picture of our stack, but also a new set of commands we may run to easily manage the entire stack.

Let’s take a look at this docker-compose.yml file:

This may look a bit daunting. Honestly, we don’t need to know all of the details. At a high level, we see we’re setting up our lamp image and the official mysql image to run together. They’ll do so under the same network. And we’re passing all those options for the ports and volumes we talked about earlier.

You’ll also notice we’re defining a few additional settings. For example, some configuration files for PHP and MySQL, as well as a secrets file containing the root password for MySQL and a generic database user.

Again, all of these are included in the jasonmccreary/local-docker-stack repo for you to download.

Now that we have this file, we may run a single command to start the entire stack of these services running within the same network.

First, we need to initialize Docker for our stack. To do so, we’ll run the following command just once:

Now we’ll run our stack with:

This takes the path to our docker-compose.yml file and a name of the stack. In this case, I simply named it dev . But you can call it whatever you want.

To see both containers running, we may run the docker container ps command from earlier. And based on its output, we may use the container ID to interact with either of the containers in the stack by passing it to docker exec .

Directing web traffic

Even though everything’s running, our server is likely not directing web traffic to the appropriate location. Similar to our local install before we need to direct web traffic to our Docker web server.

Similar to configuring Apache virtual hosts on macOS, I do this by editing my hosts file. The only difference now is I use a .wip extension, rather than a .local . This sometimes conflicted with Bonjour and local macOS networking. I liked .dev , but Google took it.

While .wip isn’t my first choice, so many extensions exist now. So .wip won mostly being a fun acronym, three letters, and available. Again, you’re welcome to choose any available extension you like.

To edit the hosts file, run:

I’ll append an entry to the end of the file:

In this case, the entry is for viewing this very blog in my local development environment. This handles directing traffic to Docker (technically localhost, but that’s where Docker is listening). Now we need to set up Docker to receive and handle the traffic accordingly.

We actually configured our lamp service to load the virtual hosts from a local apache/vhosts.conf . This file is built by a simple shell script, also found within the apache folder. This script concatenates all my virtual host configuration files within my workspace under

/workspace/apache-vhosts into a single vhosts.conf file.

Anytime I’m working on a new web project, I create a new virtual hosts file. Then I can run this script to pack them all down into a single file which will be configured.

Stopping and restarting our stack

To stop the stack, the best option is to run the following command:

This is safe as it brings the services down gracefully. However, you may simply quit Docker Desktop Client as well. This could result in data loss by abruptly stopping a service. Sometimes I have noticed some network issues. But typically running this command resolves them.

To start the server, we run the same compose command as before:

Remember, running this command will start new containers with new IDs. So be sure to run docker container ps to get the latest ID to pass to the other commands like docker exec .

Otherwise, Docker will remember everything else. The volumes will mount with all your files and databases. The web server will boot with your Apache virtual hosts. And, of course, your hosts file remains the same.

File sync issues

After upgrading to Docker 2.4 I experienced intermittent file sync issues. I resolved this by disabling «Use gRPC FUSE for file sharing» within the Preferences of the Docker Desktop Client.

Closing

I start with this tutorial because I believe it’s an easy way to get started with Docker. It also most closely resembles the previous installation of PHP, MySQL, and Apache on macOS locally.

Admittedly, I’ve also taken some liberties with the terms that Docker gurus may not agree with. But it’s a start as you get familiar with using Docker.

I encourage you to get familiar with the different commands. Learn the terms. Tweak this setup. Feel some of the pain. Once you do, you should have enough of a foundation to do even more.

You may also review the following articles below which include some additional services and minor tweaks to make your local Docker development environment even better.

I want to thank Ralph Schindler, Chris Fidao, and Dana Luther for answering countless questions I’ve asked over the last year. Without their help, this tutorial would not exist.

Find this interesting? Let’s continue the conversation on Twitter.

Источник