### 2.9.4 Installing MySQL Using a Standard Source Distribution

 To install MySQL from a standard source distribution:

1. Verify that your system satisfies the tool requirements listed at [Section 2.9.2, “Source Installation Prerequisites”](source-installation-prerequisites.html).

2. Obtain a distribution file using the instructions in [Section 2.1.3, “How to Get MySQL”](getting-mysql.html).

3. Configure, build, and install the distribution using the instructions in this section.

4. Perform postinstallation procedures using the instructions in [Section 2.10, “Postinstallation Setup and Testing”](postinstallation.html).

 MySQL uses **CMake** as the build framework on all platforms. The instructions given here should enable you to produce a working installation. For additional information on using **CMake** to build MySQL, see [How to Build MySQL Server with CMake](https://dev.mysql.com/doc/internals/en/cmake.html).

 If you start from a source RPM, use the following command to make a binary RPM that you can install. If you do not have **rpmbuild**, use **rpm** instead.

```
$> rpmbuild --rebuild --clean MySQL-VERSION.src.rpm
```

 The result is one or more binary RPM packages that you install as indicated in [Section 2.5.4, “Installing MySQL on Linux Using RPM Packages from Oracle”](linux-installation-rpm.html).

 The sequence for installation from a compressed **tar** file or Zip archive source distribution is similar to the process for installing from a generic binary distribution (see [Section 2.2, “Installing MySQL on Unix/Linux Using Generic Binaries”](binary-installation.html)), except that it is used on all platforms and includes steps to configure and compile the distribution. For example, with a compressed **tar** file source distribution on Unix, the basic installation command sequence looks like this:

```
# Preconfiguration setup
$> groupadd mysql
$> useradd -r -g mysql -s /bin/false mysql
# Beginning of source-build specific instructions
$> tar zxvf mysql-VERSION.tar.gz
$> cd mysql-VERSION
$> mkdir bld
$> cd bld
$> cmake ..
$> make
$> make install
# End of source-build specific instructions
# Postinstallation setup
$> cd /usr/local/mysql
$> mkdir mysql-files
$> chown mysql:mysql mysql-files
$> chmod 750 mysql-files
$> bin/mysqld --initialize --user=mysql
$> bin/mysql_ssl_rsa_setup
$> bin/mysqld_safe --user=mysql &
# Next command is optional
$> cp support-files/mysql.server /etc/init.d/mysql.server
```

 A more detailed version of the source-build specific instructions is shown following.

Note

 The procedure shown here does not set up any passwords for MySQL accounts. After following the procedure, proceed to [Section 2.10, “Postinstallation Setup and Testing”](postinstallation.html), for postinstallation setup and testing.

* [Perform Preconfiguration Setup](installing-source-distribution.html#installing-source-distribution-preconfiguration)

* [Obtain and Unpack the Distribution](installing-source-distribution.html#installing-source-distribution-obtain-distribution)

* [Configure the Distribution](installing-source-distribution.html#installing-source-distribution-configure-distribution)

* [Build the Distribution](installing-source-distribution.html#installing-source-distribution-build-distribution)

* [Install the Distribution](installing-source-distribution.html#installing-source-distribution-install-distribution)

* [Perform Postinstallation Setup](installing-source-distribution.html#installing-source-distribution-postinstallation)

#### Perform Preconfiguration Setup

 On Unix, set up the `mysql` user and group that should be used to run and execute the MySQL server, and own the database directory. For details, see [Create a mysql User and Group](binary-installation.html#binary-installation-createsysuser). Then perform the following steps as the `mysql` user, except as noted.

#### Obtain and Unpack the Distribution

 Pick the directory under which you want to unpack the distribution and change location into it.

 Obtain a distribution file using the instructions in [Section 2.1.3, “How to Get MySQL”](getting-mysql.html).

 Unpack the distribution into the current directory:

* To unpack a compressed **tar** file, **tar** can uncompress and unpack the distribution if it has `z` option support:

  ```
  $> tar zxvf mysql-VERSION.tar.gz
  ```

   If your **tar** does not have `z` option support, use **gunzip** to unpack the distribution and **tar** to unpack it:

  ```
  $> gunzip < mysql-VERSION.tar.gz | tar xvf -
  ```

   Alternatively, **CMake** can uncompress and unpack the distribution:

  ```
  $> cmake -E tar zxvf mysql-VERSION.tar.gz
  ```

* To unpack a Zip archive, use **WinZip** or another tool that can read `.zip` files.

 Unpacking the distribution file creates a directory named `mysql-*`VERSION`*`.

#### Configure the Distribution

 Change location into the top-level directory of the unpacked distribution:

```
$> cd mysql-VERSION
```

 Build outside of the source tree to keep the tree clean. If the top-level source directory is named `mysql-src` under your current working directory, you can build in a directory named `bld` at the same level. Create the directory and go there:

```
$> mkdir bld
$> cd bld
```

 Configure the build directory. The minimum configuration command includes no options to override configuration defaults:

```
$> cmake ../mysql-src
```

 The build directory needs not be outside the source tree. For example, you can build in a directory named `bld` under the top-level source tree. To do this, starting with `mysql-src` as your current working directory, create the directory `bld` and then go there:

```
$> mkdir bld
$> cd bld
```

 Configure the build directory. The minimum configuration command includes no options to override configuration defaults:

```
$> cmake ..
```

 If you have multiple source trees at the same level (for example, to build multiple versions of MySQL), the second strategy can be advantageous. The first strategy places all build directories at the same level, which requires that you choose a unique name for each. With the second strategy, you can use the same name for the build directory within each source tree. The following instructions assume this second strategy.

 On Windows, specify the development environment. For example, the following commands configure MySQL for 32-bit or 64-bit builds, respectively:

```
$> cmake .. -G "Visual Studio 12 2013"
$> cmake .. -G "Visual Studio 12 2013 Win64"
```

 On macOS, to use the Xcode IDE:

```
$> cmake .. -G Xcode
```

 When you run **cmake**, you might want to add options to the command line. Here are some examples:

* [`-DBUILD_CONFIG=mysql_release`](source-configuration-options.html#option_cmake_build_config): Configure the source with the same build options used by Oracle to produce binary distributions for official MySQL releases.

* [`-DCMAKE_INSTALL_PREFIX=*`dir_name`*`](source-configuration-options.html#option_cmake_cmake_install_prefix): Configure the distribution for installation under a particular location.

* [`-DCPACK_MONOLITHIC_INSTALL=1`](source-configuration-options.html#option_cmake_cpack_monolithic_install): Cause **make package** to generate a single installation file rather than multiple files.

* [`-DWITH_DEBUG=1`](source-configuration-options.html#option_cmake_with_debug): Build the distribution with debugging support.

 For a more extensive list of options, see [Section 2.9.7, “MySQL Source-Configuration Options”](source-configuration-options.html).

 To list the configuration options, use one of the following commands:

```
$> cmake .. -L   # overview
$> cmake .. -LH  # overview with help text
$> cmake .. -LAH # all params with help text
$> ccmake ..     # interactive display
```

 If **CMake** fails, you might need to reconfigure by running it again with different options. If you do reconfigure, take note of the following:

[]()[]()

* If **CMake** is run after it has previously been run, it may use information that was gathered during its previous invocation. This information is stored in `CMakeCache.txt`. When **CMake** starts, it looks for that file and reads its contents if it exists, on the assumption that the information is still correct. That assumption is invalid when you reconfigure.

* Each time you run **CMake**, you must run **make** again to recompile. However, you may want to remove old object files from previous builds first because they were compiled using different configuration options.

 To prevent old object files or configuration information from being used, run these commands in the build direcotry on Unix before re-running **CMake**:

```
$> make clean
$> rm CMakeCache.txt
```

 Or, on Windows:

```
$> devenv MySQL.sln /clean
$> del CMakeCache.txt
```

 Before asking on the [MySQL Community Slack](https://mysqlcommunity.slack.com/), check the files in the `CMakeFiles` directory for useful information about the failure. To file a bug report, please use the instructions in [Section 1.6, “How to Report Bugs or Problems”](bug-reports.html).

#### Build the Distribution

 On Unix:

```
$> make
$> make VERBOSE=1
```

 The second command sets `VERBOSE` to show the commands for each compiled source.

 Use **gmake** instead on systems where you are using GNU **make** and it has been installed as **gmake**.

 On Windows:

```
$> devenv MySQL.sln /build RelWithDebInfo
```

 If you have gotten to the compilation stage, but the distribution does not build, see [Section 2.9.8, “Dealing with Problems Compiling MySQL”](compilation-problems.html), for help. If that does not solve the problem, please enter it into our bugs database using the instructions given in [Section 1.6, “How to Report Bugs or Problems”](bug-reports.html). If you have installed the latest versions of the required tools, and they crash trying to process our configuration files, please report that also. However, if you get a `command not found` error or a similar problem for required tools, do not report it. Instead, make sure that all the required tools are installed and that your `PATH` variable is set correctly so that your shell can find them.

#### Install the Distribution

 On Unix:

```
$> make install
```

 This installs the files under the configured installation directory (by default, `/usr/local/mysql`). You might need to run the command as `root`.

 To install in a specific directory, add a `DESTDIR` parameter to the command line:

```
$> make install DESTDIR="/opt/mysql"
```

 Alternatively, generate installation package files that you can install where you like:

```
$> make package
```

 This operation produces one or more `.tar.gz` files that can be installed like generic binary distribution packages. See [Section 2.2, “Installing MySQL on Unix/Linux Using Generic Binaries”](binary-installation.html). If you run **CMake** with [`-DCPACK_MONOLITHIC_INSTALL=1`](source-configuration-options.html#option_cmake_cpack_monolithic_install), the operation produces a single file. Otherwise, it produces multiple files.

 On Windows, generate the data directory, then create a `.zip` archive installation package:

```
$> devenv MySQL.sln /build RelWithDebInfo /project initial_database
$> devenv MySQL.sln /build RelWithDebInfo /project package
```

 You can install the resulting `.zip` archive where you like. See [Section 2.3.4, “Installing MySQL on Microsoft Windows Using a `noinstall` ZIP Archive”](windows-install-archive.html).

#### Perform Postinstallation Setup

 The remainder of the installation process involves setting up the configuration file, creating the core databases, and starting the MySQL server. For instructions, see [Section 2.10, “Postinstallation Setup and Testing”](postinstallation.html).

Note

 The accounts that are listed in the MySQL grant tables initially have no passwords. After starting the server, you should set up passwords for them using the instructions in [Section 2.10, “Postinstallation Setup and Testing”](postinstallation.html).

