> ## Documentation Index
> Fetch the complete documentation index at: https://tyk.io/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Install Tyk Self-Managed on Linux

> Installation guide for the Tyk Self-Managed on on Linux distributions using Ubuntu, Debian, Red Hat, and CentOS

| Edition    | Deployment Type      |
| :--------- | :------------------- |
| Enterprise | Self-Managed, Hybrid |

## Compatible Operating Systems

| Operating System         | Version                                     |
| ------------------------ | ------------------------------------------- |
| Ubuntu                   | 20.04 (focal), 22.04 (jammy), 24.04 (noble) |
| Red Hat Enterprise Linux | 7.9, 8.9, 9.3                               |
| CentOS Stream            | Stream 9, Stream 10                         |
| Debian                   | 11 (Bullseye), 12 (Bookworm)                |
| Amazon Linux             | 2023.7                                      |

### Binaries

Installation packages for supported Linux distributions are available on [packagecloud.io](https://packagecloud.io/tyk).

## Prerequisites

* [Enterprise Edition License](/5.12/apim#licensing)

## Red Hat (RHEL / CentOS)

<a id="install-tyk-on-redhat-rhel-centos" />

There are 4 components which needs to be installed.

### Install Database

#### Redis

Tyk Gateway has a [dependency](/5.12/planning-for-production/database-settings#redis) on Redis. Follow the steps provided by Red Hat to make the installation of Redis, conducting a [search](https://access.redhat.com/search/?q=redis) for the correct version and distribution.

#### Storage Database

Tyk Dashboard has a dependency on a storage database that can be [PostgreSQL](/5.12/planning-for-production/database-settings#postgresql) or [MongoDB](/5.12/planning-for-production/database-settings#mongodb-sizing-guidelines).

<Tabs>
  <Tab title="PostgreSQL">
    Check the PostgreSQL supported [versions](/5.12/planning-for-production/database-settings#postgresql). Follow the steps provided by [PostgreSQL](https://www.postgresql.org/download/linux/redhat/) to install it.

    Configure PostgreSQL

    Create a new role/user

    ```console theme={null}
    sudo -u postgres createuser --interactive
    ```

    The name of the role can be "tyk" and say yes to make it a superuser

    Create a matching DB with the same name. Postgres authentication system assumes by default that for any role used to log in, that role will have a database with the same name which it can access.

    ```console theme={null}
    sudo -u postgres createdb tyk
    ```

    Add another user to be used to log into your operating system

    ```console theme={null}
    sudo adduser tyk
    ```

    Log in to your Database

    ```console theme={null}
    sudo -u tyk psql
    ```

    Update the user “tyk” to have a password

    ```console theme={null}
    ALTER ROLE tyk with PASSWORD '123456';
    ```

    Create a DB (my example is tyk\_analytics)

    ```console theme={null}
    sudo -u tyk createdb tyk_analytics
    ```
  </Tab>

  <Tab title="MongoDB">
    Check the MongoDB supported [versions](/5.12/planning-for-production/database-settings#mongodb-sizing-guidelines). Follow the steps provided by [MongoDB](https://www.mongodb.com/docs/manual/tutorial/install-mongodb-on-red-hat/) to install it.

    Optionally initialize the database and enable automatic start:

    ```console theme={null}
    # Optionally ensure that MongoDB will start following a system reboot
    sudo systemctl enable mongod
    # start MongoDB server
    sudo systemctl start mongod
    ```
  </Tab>
</Tabs>

### Install Dashboard

Tyk has its own signed RPMs in a YUM repository hosted by the kind folks at [packagecloud.io](https://packagecloud.io/tyk/tyk-dashboard/install#manual-rpm), which makes it easy, safe and secure to install a trusted distribution of the Tyk Gateway stack.

This configuration should also work (with some tweaks) for CentOS.

**Prerequisites**

* Ensure port `3000` is open: This is used by the Dashboard to provide the GUI and the Classic Developer Portal.
* Follow the steps provided in this link [Getting started on Red Hat (RHEL / CentOS)](/5.12/#install-tyk-on-redhat-rhel-centos) to install and configure Tyk dependencies.

1. **Set up YUM Repositories**

   First, install two package management utilities `yum-utils` and a file downloading tool `wget`:

   ```bash theme={null}
   sudo yum install yum-utils wget
   ```

   Then install Python:

   ```bash theme={null}
   sudo yum install python3
   ```

2. **Configure and Install the Tyk Dashboard**

   Create a file named `/etc/yum.repos.d/tyk_tyk-dashboard.repo` that contains the repository configuration settings for YUM repositories `tyk_tyk-dashboard` and `tyk_tyk-dashboard-source` used to download packages from the specified URLs, including GPG key verification and SSL settings, on a Linux system.

   Make sure to replace `el` and `8` in the config below with your Linux distribution and version:

   ```bash theme={null}
   [tyk_tyk-dashboard]
   name=tyk_tyk-dashboard
   baseurl=https://packagecloud.io/tyk/tyk-dashboard/el/8/$basearch
   repo_gpgcheck=1
   gpgcheck=0
   enabled=1
   gpgkey=https://packagecloud.io/tyk/tyk-dashboard/gpgkey
   sslverify=1
   sslcacert=/etc/pki/tls/certs/ca-bundle.crt
   metadata_expire=300

   [tyk_tyk-dashboard-source]
   name=tyk_tyk-dashboard-source
   baseurl=https://packagecloud.io/tyk/tyk-dashboard/el/8/SRPMS
   repo_gpgcheck=1
   gpgcheck=0
   enabled=1
   gpgkey=https://packagecloud.io/tyk/tyk-dashboard/gpgkey
   sslverify=1
   sslcacert=/etc/pki/tls/certs/ca-bundle.crt
   metadata_expire=300
   ```

   We'll need to update the YUM package manager's local cache, enabling only the `tyk_tyk-dashboard` repository while disabling all other repositories `--disablerepo='*' --enablerepo='tyk_tyk-dashboard'`, and confirm all prompts `-y`.

   ```bash theme={null}
   sudo yum -q makecache -y --disablerepo='*' --enablerepo='tyk_tyk-dashboard'
   ```

   Install Tyk dashboard:

   ```bash theme={null}
   sudo yum install -y tyk-dashboard
   ```

3. **Confirm Redis and MongoDB or PostgreSQL are running**

   Start Redis since it is always required by the Dashboard.

   ```bash theme={null}
   sudo service redis start
   ```

   Then start either MongoDB or PostgreSQL depending on which one you are using.

   ```bash theme={null}
   sudo systemctl start mongod
   ```

   ```bash theme={null}
   sudo systemctl start postgresql-13
   ```

4. **Configure Tyk Dashboard**

We can set the Dashboard up with a similar setup command, the script below will get the Dashboard set up for the local instance.
Make sure to use the actual DNS hostname or the public IP of your instance as the last parameter.

<Tabs>
  <Tab title="MongoDB">
    ```bash theme={null}
    sudo /opt/tyk-dashboard/install/setup.sh --listenport=3000 --redishost=<Redis Hostname> --redisport=6379 --mongo=mongodb://<Mongo IP Address>:<Mongo Port>/tyk_analytics --tyk_api_hostname=$HOSTNAME --tyk_node_hostname=http://localhost --tyk_node_port=8080 --portal_root=/portal --domain="XXX.XXX.XXX.XXX"
    ```

    Replace `<Redis Hostname>`, `<Mongo IP Address>` and `<Mongo Port>` with your own values to run this script.
  </Tab>

  <Tab title="SQL">
    ```bash theme={null}
    sudo /opt/tyk-dashboard/install/setup.sh --listenport=3000 --redishost=<Redis Hostname> --redisport=6379 --storage=postgres --connection_string=postgresql://<User>:<Password>@<PostgreSQL Hostname>:<PostgreSQL Port>/<PostgreSQL DB> --tyk_api_hostname=$HOSTNAME --tyk_node_hostname=http://localhost --tyk_node_port=8080 --portal_root=/portal --domain="XXX.XXX.XXX.XXX"
    ```

    Replace `<Redis Hostname>`,`<PostgreSQL Hostname>`,`<PostgreSQL Port>`, `<PostgreSQL User>`, `<PostgreSQL Password>` and `<PostgreSQL DB>` with your own values to run the script.
  </Tab>
</Tabs>

With these values your are configuring the following:

* `--listenport=3000`: Tyk Dashboard (and Portal) to listen on port `3000`.
* `--redishost=<hostname>`: Tyk Dashboard should use the local Redis instance.
* `--redisport=6379`: The Tyk Dashboard should use the default port.
* `--domain="XXX.XXX.XXX.XXX"`: Bind the Dashboard to the IP or DNS hostname of this instance (required).
* `--mongo=mongodb://<Mongo IP Address>:<Mongo Port>/tyk_analytics`: Use the local MongoDB (should always be the same as the Gateway).
* `--storage=postgres`: In case, your preferred storage Database is PostgreSQL, use storage type "postgres" and specify connection string.
* `--connection_string=postgresql://<User>:<Password>@<PostgreSQL Host Name>:<PostgreSQL Port>/<PostgreSQL DB>`: Use the PostgreSQL instance provided in the connection string (should always be the same as the gateway).
* `--tyk_api_hostname=$HOSTNAME`: The Tyk Dashboard has no idea what hostname has been given to Tyk, so we need to tell it, in this instance we are just using the local HOSTNAME env variable, but you could set this to the public-hostname/IP of the instance.
* `--tyk_node_hostname=http://localhost`: The Tyk Dashboard needs to see a Tyk node in order to create new tokens, so we need to tell it where we can find one, in this case, use the one installed locally.
* `--tyk_node_port=8080`: Tell the Dashboard that the Tyk node it should communicate with is on port 8080.
* `--portal_root=/portal`: We want the Portal to be shown on /portal of whichever domain we set for the Portal.

5. **Start Tyk Dashboard**

   ```bash theme={null}
   sudo service tyk-dashboard start
   ```

   <Note>
     To check the logs from the deployment run:

     ```bash theme={null}
     sudo journalctl -u tyk-dashboard 
     ```
   </Note>

   Notice how we haven't actually started the gateway yet, because this is a Dashboard install, we need to enter a license first.

<Note>
  When using PostgreSQL you may receive the error: `"failed SASL auth (FATAL: password authentication failed for user...)"`, follow these steps to address the issue:

  1. Open the terminal or command prompt on your PostgreSQL server.
  2. Navigate to the location of the `pg_hba.conf` file. This file is typically located at `/var/lib/pgsql/13/data/pg_hba.conf`.
  3. Open the `pg_hba.conf` file using a text manipulation tool.
  4. In the  `pg_hba.conf` file, locate the entry corresponding to the user encountering the authentication error. This entry might resemble the following:

  ```bash theme={null}
  host    all    all    <IP_address>/<netmask>    scram-sha-256
  ```

  5. In the entry, find the METHOD column. It currently has the value scram-sha-256.
  6. Replace scram-sha-256 with md5, so the modified entry looks like this:

  ```bash theme={null}
  host    all    all    <IP_address>/<netmask>    md5
  ```

  7. Save the changes you made to the `pg_hba.conf` file.
  8. Restart the PostgreSQL service to apply the modifications:

  ```bash theme={null}
  sudo systemctl restart postgresql-13
  ```
</Note>

6. **Enter Dashboard license**

   Add your license in `/var/opt/tyk-dashboard/tyk_analytics.conf` in the `license` field.

   If all is going well, you will be taken to a Dashboard setup screen - we'll get to that soon.

7. **Restart the Dashboard process**

   Because we've just entered a license via the UI, we need to make sure that these changes get picked up, so to make sure things run smoothly, we restart the Dashboard process (you only need to do this once) and (if you have it installed) then start the gateway:

   ```bash theme={null}
   sudo service tyk-dashboard restart 
   ```

8. **Go to the Tyk Dashboard URL**

   Go to the following URL to access to the Tyk Dashboard:

   ```bash theme={null}
   127.0.0.1:3000
   ```

   You should get to the Tyk Dashboard Setup screen:

   <img src="https://mintcdn.com/tyk/5UCBGp0ycRfPh9jq/img/dashboard/system-management/bootstrap_screen.png?fit=max&auto=format&n=5UCBGp0ycRfPh9jq&q=85&s=2c55502b97178c8a0fcc9c0818a9edb1" alt="Tyk Dashboard Bootstrap Screen" width="1708" height="1367" data-path="img/dashboard/system-management/bootstrap_screen.png" />

9. **Create your Organization and Default User**

   You need to enter the following:

   * Your **Organization Name**
   * Your **Organization Slug**
   * Your User **Email Address**
   * Your User **First and Last Name**
   * A **Password** for your User
   * **Re-enter** your user **Password**

   <Note>
     For a password, we recommend a combination of alphanumeric characters, with both upper and lower case letters.
   </Note>

   Click **Bootstrap** to save the details.

10. **Login to the Dashboard**

    You can now log in to the Tyk Dashboard from `127.0.0.1:3000`, using the username and password created in the Dashboard Setup screen.

    **Configure your Developer Portal**

    To set up your [Developer Portal](/5.12/portal/overview/intro) follow our Self-Managed [tutorial on publishing an API to the Portal Catalog](/5.12/getting-started/tutorials/publish-api).

### Install Pump

Tyk has it's own signed RPMs in a YUM repository hosted by the kind folks at [packagecloud.io](https://packagecloud.io), which makes it easy, safe and secure to install a trusted distribution of the Tyk Gateway stack.

This tutorial will run on an [Amazon AWS](http://aws.amazon.com) *Red Hat Enterprise Linux 7.1* instance. We will install Tyk Pump with all dependencies stored locally.

We're installing on a `t2.micro` because this is a tutorial, you'll need more RAM and more cores for better performance.

This configuration should also work (with some tweaks) for CentOS.

**Prerequisites**

We are assuming that Redis and either MongoDB or SQL are installed (these are installed as part of the Tyk Gateway and Dashboard installation guides)

**Step 1: Set up YUM Repositories**

First, we need to install some software that allows us to use signed packages:

```bash theme={null}
sudo yum install pygpgme yum-utils wget
```

Next, we need to set up the various repository configurations for Tyk and MongoDB:

Create a file named `/etc/yum.repos.d/tyk_tyk-pump.repo` that contains the repository configuration below:

Make sure to replace `el` and `7` in the config below with your Linux distribution and version:

```bash theme={null}
[tyk_tyk-pump]
name=tyk_tyk-pump
baseurl=https://packagecloud.io/tyk/tyk-pump/el/7/$basearch
repo_gpgcheck=1
gpgcheck=1
enabled=1
gpgkey=https://keyserver.tyk.io/tyk.io.rpm.signing.key.2020
       https://packagecloud.io/tyk/tyk-pump/gpgkey
sslverify=1
sslcacert=/etc/pki/tls/certs/ca-bundle.crt
metadata_expire=300
```

Finally we'll need to update our local cache, so run:

```bash theme={null}
sudo yum -q makecache -y --disablerepo='*' --enablerepo='tyk_tyk-pump'
```

**Step 2: Install Packages**

We're ready to go, you can now install the relevant packages using yum:

```bash theme={null}
sudo yum install -y tyk-pump
```

**(You may be asked to accept the GPG key for our repos and when the package installs, hit yes to continue.)**

<br />

**Step 3: Configure Tyk Pump**

If you don't complete this step, you won't see any analytics in your Dashboard, so to enable the analytics service, we need to ensure Tyk Pump is running and configured properly.

**Configure Tyk Pump for MongoDB**

<br />

<Note>
  You need to replace `<hostname>` for `--redishost=<hostname>`, and `<Mongo IP Address>`, `<Mongo Port>`  for `--mongo=mongodb://<Mongo IP Address>:<Mongo Port>/` with your own values to run this script.
</Note>

```bash theme={null}
sudo /opt/tyk-pump/install/setup.sh --redishost=<hostname> --redisport=6379 --mongo=mongodb://<IP Address>:<Mongo Port>/tyk_analytics
```

**Configure Tyk Pump for SQL**

<br />

<Note>
  You need to replace `<hostname>` for `--redishost=<hostname>`, and `<Postgres Host Name>`,`<Port>`, `<User>`, `<Password>`, `<DB>` for `--postgres="host=<Postgres Host Name> port=<Port> user=<User> password=<Password> dbname=<DB>"` with your own values to run this script.
</Note>

```bash theme={null}
sudo /opt/tyk-pump/install/setup.sh --redishost=<hostname> --redisport=6379 --postgres="host=<Postgres Host Name> port=<Port> user=<User> password=<Password> dbname=<DB>"
```

**Step 4: Start Tyk Pump**

```bash theme={null}
sudo service tyk-pump start
```

That's it, the Pump should now be up and running.

You can verify if Tyk Pump is running and working by accessing the logs:

```bash theme={null}
sudo journalctl -u tyk-pump
```

### Install Gateway

Tyk has it's own signed RPMs in a YUM repository hosted by the kind folks at [packagecloud.io](https://packagecloud.io/tyk/tyk-dashboard/install#manual-rpm), which makes it easy, safe and secure to install a trusted distribution of the Tyk Gateway stack.

This tutorial will run on an [Amazon AWS](http://aws.amazon.com) *Red Hat Enterprise Linux 7.1* instance. We will install Tyk Gateway with all dependencies stored locally.

We're installing on a `t2.micro` because this is a tutorial, you'll need more RAM and more cores for better performance.

This configuration should also work (with some tweaks) for CentOS.

**Prerequisites**

* Ensure port `8080` is open: this is used in this guide for Gateway traffic (API traffic to be proxied)
* EPEL (Extra Packages for Enterprise Linux) is a free, community based repository project from Fedora which provides high quality add-on software packages for Linux distribution including RHEL, CentOS, and Scientific Linux. EPEL isn’t a part of RHEL/CentOS but it is designed for major Linux distributions. In our case we need it for Redis. Install EPEL using the instructions here.

**Step 1: Set up YUM Repositories**

First, we need to install some software that allows us to use signed packages:

```bash theme={null}
sudo yum install pygpgme yum-utils wget
```

Next, we need to set up the various repository configurations for Tyk and MongoDB:

**Step 2: Create Tyk Gateway Repository Configuration**

Create a file named `/etc/yum.repos.d/tyk_tyk-gateway.repo` that contains the repository configuration below [https://packagecloud.io/tyk/tyk-gateway/install#manual-rpm](https://packagecloud.io/tyk/tyk-gateway/install#manual-rpm):

```bash theme={null}
[tyk_tyk-gateway]
name=tyk_tyk-gateway
baseurl=https://packagecloud.io/tyk/tyk-gateway/el/7/$basearch
repo_gpgcheck=1
gpgcheck=1
enabled=1
gpgkey=https://keyserver.tyk.io/tyk.io.rpm.signing.key.2020
       https://packagecloud.io/tyk/tyk-gateway/gpgkey
sslverify=1
sslcacert=/etc/pki/tls/certs/ca-bundle.crt
metadata_expire=300
```

**Step 3: Install Packages**

We're ready to go, you can now install the relevant packages using yum:

```bash theme={null}
sudo yum install -y redis tyk-gateway
```

*(you may be asked to accept the GPG key for our two repos and when the package installs, hit yes to continue)*

**Step 4: Start Redis**

In many cases Redis will not be running, so let's start those:

```bash theme={null}
sudo service redis start
```

When Tyk is finished installing, it will have installed some init scripts, but it will not be running yet. The next step will be to setup the Gateway – thankfully this can be done with three very simple commands.

## Install Tyk on Debian or Ubuntu

### Install Database

**Requirements**

Before installing the Tyk components in the order below, you need to first install Redis and MongoDB/SQL.

**Getting Started**

<Tabs>
  <Tab title="MongoDB">
    **Install MongoDB 4.0**

    You should follow the [online tutorial for installing MongoDb](https://docs.mongodb.com/v4.0/tutorial/install-mongodb-on-ubuntu/). We will be using version 4.0. As part of the Mongo installation you need to perform the following:

    1. Import the public key
    2. Create a list file
    3. Reload the package database
    4. Install the MongoDB packages
    5. Start MongoDB
    6. Check the `mongod` service is running
  </Tab>

  <Tab title="SQL">
    **Install SQL**

    You should follow the [online tutorial for installing PostgreSQL](https://www.postgresql.org/download/linux/ubuntu/). We will be using version 13. As part of the PostgreSQL installation you need to perform the following:

    1. Create the file repository configuration
    2. Import the repository signing key
    3. Update the package lists
    4. Install the PostgreSQL packages
    5. Start PostgreSQL
    6. Check the `postgresql` service is running

    See [SQL configuration](/5.12/planning-for-production/database-settings#postgresql) for details on installing SQL in a production environment.
  </Tab>
</Tabs>

**Install Redis**

```console theme={null}
$ sudo apt-get install -y redis-server
```

<Note>
  For a production environment, we recommend that the Gateway, Dashboard and Pump are installed on separate machines. If installing multiple Gateways, you should install each on a separate machine. See [Planning for Production](/5.12/planning-for-production) For more details.
</Note>

### Install Dashboard

<a id="Debian-Ubuntu-install-dashboard" />

Tyk has its own APT repositories hosted by the kind folks at [packagecloud.io](https://packagecloud.io/tyk), which makes it easy, safe and secure to install a trusted distribution of the Tyk Gateway stack.

This tutorial has been tested on Ubuntu 16.04 & 18.04 with few if any modifications. We will install the Tyk Dashboard with all dependencies locally.

**Prerequisites**

* Have MongoDB/SQL and Redis installed - follow the guide for [installing databases on Debian/Ubuntu](/5.12/#install-tyk-on-debian-or-ubuntu).
* Ensure port `3000` is available. This is used by the Tyk Dashboard to provide the GUI and the Developer Portal.

**Step 1: Set up our APT Repositories**

First, add our GPG key which signs our binaries:

```bash theme={null}
curl -L https://packagecloud.io/tyk/tyk-dashboard/gpgkey | sudo apt-key add -
```

Run update:

```bash theme={null}
sudo apt-get update
```

Since our repositories are installed via HTTPS, you will need to make sure APT supports this:

```bash theme={null}
sudo apt-get install -y apt-transport-https
```

Now lets add the required repos and update again (notice the `-a` flag in the second Tyk commands - this is important!):

```bash theme={null}
echo "deb https://packagecloud.io/tyk/tyk-dashboard/ubuntu/ bionic main" | sudo tee /etc/apt/sources.list.d/tyk_tyk-dashboard.list

echo "deb-src https://packagecloud.io/tyk/tyk-dashboard/ubuntu/ bionic main" | sudo tee -a /etc/apt/sources.list.d/tyk_tyk-dashboard.list

sudo apt-get update
```

<Note>
  `bionic` is the code name for Ubuntu 18.04. Please substitute it with your particular [ubuntu release](https://releases.ubuntu.com/), e.g. `focal`.
</Note>

**What we've done here is:**

* Added the Tyk Dashboard repository
* Updated our package list

**Step 2: Install the Tyk Dashboard**

We're now ready to install the Tyk Dashboard. To install run:

```bash theme={null}
sudo apt-get install -y tyk-dashboard
```

What we've done here is instructed `apt-get` to install the Tyk Dashboard without prompting. Wait for the downloads to complete.

When the Tyk Dashboard has finished installing, it will have installed some `init` scripts, but it will not be running yet. The next step will be to setup each application - thankfully this can be done with three very simple commands.

**Verify the origin key (optional)**

Debian packages are signed with the repository keys. These keys are verified at the time of fetching the package and is taken care of by the `apt` infrastructure. These keys are controlled by PackageCloud, our repository provider. For an additional guarantee, it is possible to verify that the package was indeed created by Tyk by verifying the `origin` certificate that is attached to the package.

First, you have to fetch Tyk's signing key and import it.

```bash theme={null}
wget https://keyserver.tyk.io/tyk.io.deb.signing.key
gpg --import tyk.io.deb.signing.key
```

Then, you have to either,

* sign the key with your ultimately trusted key
* trust this key ultimately

The downloaded package will be available in `/var/cache/apt/archives`. Assuming you found the file `tyk-gateway-2.9.4_amd64.deb` there, you can verify the origin signature.

```bash theme={null}
gpg --verify d.deb
gpg: Signature made Wed 04 Mar 2020 03:05:00 IST
gpg:                using RSA key F3781522A858A2C43D3BC997CA041CD1466FA2F8
gpg: Good signature from "Team Tyk (package signing) <team@tyk.io>" [ultimate]
```

##### **Configure Tyk Dashboard**

**Prerequisites for MongoDB**

You need to ensure the MongoDB and Redis services are running before proceeding.

<Note>
  You need to replace `<hostname>` for `--redishost=<hostname>`, and `<IP Address>` for `--mongo=mongodb://<IP Address>/` with your own values to run this script.
</Note>

You can set your Tyk Dashboard up with a helper setup command script. This will get the Dashboard set up for the local instance:

```bash theme={null}
sudo /opt/tyk-dashboard/install/setup.sh --listenport=3000 --redishost=<hostname> --redisport=6379 --mongo=mongodb://<IP Address>/tyk_analytics --tyk_api_hostname=$HOSTNAME --tyk_node_hostname=http://localhost --tyk_node_port=8080 --portal_root=/portal --domain="XXX.XXX.XXX.XXX"
```

<Note>
  Make sure to use the actual DNS hostname or the public IP of your instance as the last parameter.
</Note>

What we have done here is:

* `--listenport=3000`: Told the Tyk Dashboard (and Portal) to listen on port 3000.
* `--redishost=<hostname>`: The Tyk Dashboard should use the local Redis instance.
* `--redisport=6379`: The Tyk Dashboard should use the default port.
* `--domain="XXX.XXX.XXX.XXX"`: Bind the Tyk Dashboard to the IP or DNS hostname of this instance (required).
* `--mongo=mongodb://<IP Address>/tyk_analytics`: Use the local MongoDB (should always be the same as the gateway).
* `--tyk_api_hostname=$HOSTNAME`: The Tyk Dashboard has no idea what hostname has been given to Tyk, so we need to tell it, in this instance we are just using the local HOSTNAME env variable, but you could set this to the public-hostname/IP of the instance.
* `--tyk_node_hostname=http://localhost`: The Tyk Dashboard needs to see a Tyk node in order to create new tokens, so we need to tell it where we can find one, in this case, use the one installed locally.
* `--tyk_node_port=8080`: Tell the Tyk Dashboard that the Tyk node it should communicate with is on port 8080.
* `--portal_root=/portal`: We want the portal to be shown on `/portal` of whichever domain we set for the portal.

**Prerequisites for SQL**

You need to ensure the PostgreSQL and Redis services are running before proceeding.

<Note>
  You need to replace `<hostname>` for `--redishost=<hostname>`, and `<Postgres Host Name>`, `<Port>`, `<User>`, `<Password>`, `<DB>` for `--connection_string="host=<Postgres Host Name> port=<Port> user=<User> password=<Password> dbname=<DB>"` with your own values to run this script.
</Note>

You can set the Tyk Dashboard up with a helper setup command script. This will get the Dashboard set up for the local instance:

```bash theme={null}
sudo /opt/tyk-dashboard/install/setup.sh --listenport=3000 --redishost=<hostname> --redisport=6379 --storage=postgres --connection_string="host=<Postgres Host Name> port=<Port> user=<User> password=<Password> dbname=<DB>" --tyk_api_hostname=$HOSTNAME --tyk_node_hostname=http://localhost --tyk_node_port=8080 --portal_root=/portal --domain="XXX.XXX.XXX.XXX"
```

<Note>
  Make sure to use the actual DNS hostname or the public IP of your instance as the last parameter.
</Note>

What we have done here is:

* `--listenport=3000`: Told the Tyk Dashboard (and Portal) to listen on port 3000.
* `--redishost=<hostname>`: The Tyk Dashboard should use the local Redis instance.
* `--redisport=6379`: The Tyk Dashboard should use the default port.
* `--domain="XXX.XXX.XXX.XXX"`: Bind the dashboard to the IP or DNS hostname of this instance (required).
* `--storage=postgres`: Use storage type postgres.
* `--connection_string="host=<Postgres Host Name> port=<Port> user=<User> password=<Password> dbname=<DB>"`: Use the postgres instance provided in the connection string(should always be the same as the gateway).
* `--tyk_api_hostname=$HOSTNAME`: The Tyk Dashboard has no idea what hostname has been given to Tyk, so we need to tell it, in this instance we are just using the local HOSTNAME env variable, but you could set this to the public-hostname/IP of the instance.
* `--tyk_node_hostname=http://localhost`: The Tyk Dashboard needs to see a Tyk node in order to create new tokens, so we need to tell it where we can find one, in this case, use the one installed locally.
* `--tyk_node_port=8080`: Tell the dashboard that the Tyk node it should communicate with is on port 8080.
* `--portal_root=/portal`: We want the portal to be shown on `/portal` of whichever domain we set for the portal.

**Step 1: Enter your Tyk Dashboard License**

Add your license in `/opt/tyk-dashboard/tyk_analytics.conf` in the `license` field.

**Step 2: Start the Tyk Dashboard**

Start the dashboard service, and ensure it will start automatically on system boot.

```bash theme={null}
sudo systemctl start tyk-dashboard
sudo systemctl enable tyk-dashboard
```

**Step 3: Install your Tyk Gateway**

Follow the [Gateway installation instructions](/5.12/#using-shell-7) to connect to your Dashboard instance before you continue on to step 4.

**Step 4: Bootstrap the Tyk Dashboard with an initial User and Organization**

Go to:

```bash theme={null}
127.0.0.1:3000
```

You should get to the Tyk Dashboard Setup screen:

<img src="https://mintcdn.com/tyk/5UCBGp0ycRfPh9jq/img/dashboard/system-management/bootstrap_screen.png?fit=max&auto=format&n=5UCBGp0ycRfPh9jq&q=85&s=2c55502b97178c8a0fcc9c0818a9edb1" alt="Tyk Dashboard Bootstrap Screen" width="1708" height="1367" data-path="img/dashboard/system-management/bootstrap_screen.png" />

**Step 5 - Create your Organization and Default User**

You need to enter the following:

* Your **Organization Name**
* Your **Organization Slug**
* Your User **Email Address**
* Your User **First and Last Name**
* A **Password** for your User
* **Re-enter** your user **Password**

  <Note>
    For a password, we recommend a combination of alphanumeric characters, with both upper and lower case
    letters.
  </Note>

Click **Bootstrap** to save the details.

**Step 6 - Login to the Tyk Dashboard**

You can now log in to the Tyk Dashboard from `127.0.0.1:3000`, using the username and password created in the Dashboard Setup screen.

##### **Configure your Developer Portal**

To set up your [Developer Portal](/5.12/portal/overview/intro) follow our Self-Managed [tutorial on publishing an API to the Portal Catalog](/5.12/getting-started/tutorials/publish-api).

### Install Pump

<a id="Debian-Ubuntu-install-pump" />

This tutorial has been tested Ubuntu 16.04 & 18.04 with few if any modifications.

**Prerequisites**

* You have installed Redis and either MongoDB or SQL.
* You have installed the Tyk Dashboard.

**Step 1: Set up our APT repositories**

First, add our GPG key which signs our binaries:

```bash theme={null}
curl -L https://packagecloud.io/tyk/tyk-pump/gpgkey | sudo apt-key add -
```

Run update:

```bash theme={null}
sudo apt-get update
```

Since our repositories are installed via HTTPS, you will need to make sure APT supports this:

```bash theme={null}
sudo apt-get install -y apt-transport-https
```

Now lets add the required repos and update again (notice the `-a` flag in the second Tyk commands - this is important!):

```bash theme={null}
echo "deb https://packagecloud.io/tyk/tyk-pump/ubuntu/ bionic main" | sudo tee /etc/apt/sources.list.d/tyk_tyk-pump.list

echo "deb-src https://packagecloud.io/tyk/tyk-pump/ubuntu/ bionic main" | sudo tee -a /etc/apt/sources.list.d/tyk_tyk-pump.list

sudo apt-get update
```

<Note>
  `bionic` is the code name for Ubuntu 18.04. Please substitute it with your particular [ubuntu release](https://releases.ubuntu.com/), e.g. `focal`.
</Note>

**What you've done here is:**

* Added the Tyk Pump repository
* Updated our package list

**Step 2: Install the Tyk Pump**

You're now ready to install the Tyk Pump. To install it, run:

```bash theme={null}
sudo apt-get install -y tyk-pump
```

What you've done here is instructed `apt-get` to install Tyk Pump without prompting. Wait for the downloads to complete.

When Tyk Pump has finished installing, it will have installed some `init` scripts, but it will not be running yet. The next step will be to setup each application using three very simple commands.

**Verify the origin key (optional)**

Debian packages are signed with the repository keys. These keys are verified at the time of fetching the package and is taken care of by the `apt` infrastructure. These keys are controlled by PackageCloud, our repository provider. For an additional guarantee, it is possible to verify that the package was indeed created by Tyk by verifying the `origin` certificate that is attached to the package.

First, you have to fetch Tyk's signing key and import it.

```bash theme={null}
wget https://keyserver.tyk.io/tyk.io.deb.signing.key
gpg --import tyk.io.deb.signing.key
```

Then, you have to either,

* sign the key with your ultimately trusted key
* trust this key ultimately

The downloaded package will be available in `/var/cache/apt/archives`. Assuming you found the file `tyk-gateway-2.9.3_amd64.deb` there, you can verify the origin signature.

```bash theme={null}
gpg --verify d.deb
gpg: Signature made Wed 04 Mar 2020 03:05:00 IST
gpg:                using RSA key F3781522A858A2C43D3BC997CA041CD1466FA2F8
gpg: Good signature from "Team Tyk (package signing) <team@tyk.io>" [ultimate]
```

**Step 3: Configure Tyk Pump**

If you don't complete this step, you won't see any analytics in your Dashboard, so to enable the analytics service, we need to ensure Tyk Pump is running and configured properly.

**Option 1: Configure Tyk Pump for MongoDB**

<br />

<Note>
  You need to replace `<hostname>` for `--redishost=<hostname>`, and `<IP Address>` for `--mongo=mongodb://<IP Address>/` with your own values to run this script.
</Note>

```bash theme={null}
sudo /opt/tyk-pump/install/setup.sh --redishost=<hostname> --redisport=6379 --mongo=mongodb://<IP Address>/tyk_analytics
```

**Option 2: Configure Tyk Pump for SQL**

<br />

<Note>
  You need to replace `<hostname>` for `--redishost=<hostname>`, and `<Postgres Host Name>`,`<Port>`, `<User>`, `<Password>`, `<DB>` for `--postgres="host=<Postgres Host Name> port=<Port> user=<User> password=<Password> dbname=<DB>"` with your own values to run this script.
</Note>

```bash theme={null}
sudo /opt/tyk-pump/install/setup.sh --redishost=<hostname> --redisport=6379 --postgres="host=<Postgres Host Name> port=<Port> user=<User> password=<Password> dbname=<DB>"
```

**Step 4: Start Tyk Pump**

```bash theme={null}
sudo service tyk-pump start
sudo service tyk-pump enable
```

You can verify if Tyk Pump is running and working by tailing the log file:

```bash theme={null}
sudo tail -f /var/log/upstart/tyk-pump.log
```

### Install Gateway

<a id="debian-ubuntu-install-gateway" />

Tyk has it's own APT repositories hosted by the kind folks at [packagecloud.io][1], which makes it easy, safe and secure to install a trusted distribution of the Tyk Gateway stack.

This tutorial has been tested on Ubuntu 16.04 & 18.04 with few if any modifications.

Please note however, that should you wish to write your own plugins in Python, we currently have a Python version dependency of 3.4. Python-3.4 ships with Ubuntu 14.04, however you may need to explicitly install it on newer Ubuntu Operating System releases.

**Prerequisites**

* Ensure port `8080` is available. This is used in this guide for Gateway traffic (API traffic to be proxied).
* You have MongoDB and Redis installed.
* You have installed firstly the Tyk Dashboard, then the Tyk Pump.

**Step 1: Set up our APT Repositories**

First, add our GPG key which signs our binaries:

```bash theme={null}
curl -L https://packagecloud.io/tyk/tyk-gateway/gpgkey | sudo apt-key add -
```

Run update:

```bash theme={null}
sudo apt-get update
```

Since our repositories are installed via HTTPS, you will need to make sure APT supports this:

```bash theme={null}
sudo apt-get install -y apt-transport-https 
```

Create a file `/etc/apt/sources.list.d/tyk_tyk-gateway.list` with the following contents:

```bash theme={null}
deb https://packagecloud.io/tyk/tyk-gateway/ubuntu/ bionic main
deb-src https://packagecloud.io/tyk/tyk-gateway/ubuntu/ bionic main
```

<Note>
  `bionic` is the code name for Ubuntu 18.04. Please substitute it with your particular [ubuntu release](https://releases.ubuntu.com/), e.g. `focal`.
</Note>

Now you can refresh the list of packages with:

```bash theme={null}
sudo apt-get update
```

**What we've done here is:**

* Added the Tyk Gateway repository
* Updated our package list

**Step 2: Install the Tyk Gateway**

We're now ready to install the Tyk Gateway. To install it, run:

```bash theme={null}
sudo apt-get install -y tyk-gateway
```

What we've done here is instructed apt-get to install the Tyk Gateway without prompting, wait for the downloads to complete.

When Tyk has finished installing, it will have installed some init scripts, but will not be running yet. The next step will be to set up the Gateway - thankfully this can be done with three very simple commands, however it does depend on whether you are configuring Tyk Gateway for use with the Dashboard or without (the Community Edition).

**Verify the origin key (optional)**

Debian packages are signed with the repository keys. These keys are verified at the time of fetching the package and is taken care of by the `apt` infrastructure. These keys are controlled by PackageCloud, our repository provider. For an additional guarantee, it is possible to verify that the package was indeed created by Tyk by verifying the `origin` certificate that is attached to the package.

First, you have to fetch Tyk's signing key and import it.

```bash theme={null}
wget https://keyserver.tyk.io/tyk.io.deb.signing.key
gpg --import tyk.io.deb.signing.key
```

Then, you have to either,

* sign the key with your ultimately trusted key
* trust this key ultimately

The downloaded package will be available in `/var/cache/apt/archives`. Assuming you found the file `tyk-gateway-2.9.4_amd64.deb` there, you can verify the origin signature.

```bash theme={null}
gpg --verify d.deb
gpg: Signature made Wed 04 Mar 2020 03:05:00 IST
gpg:                using RSA key F3781522A858A2C43D3BC997CA041CD1466FA2F8
gpg: Good signature from "Team Tyk (package signing) <team@tyk.io>" [ultimate]
```

**Configure Tyk Gateway with Dashboard**

**Prerequisites**

This configuration assumes that you have already installed the Tyk Dashboard, and have decided on the domain names for your Dashboard and your Portal. **They must be different**. For testing purposes, it is easiest to add hosts entries to your (and your servers) `/etc/hosts` file.

**Set up Tyk**

You can set up the core settings for Tyk Gateway with a single setup script, however for more involved deployments, you will want to provide your own configuration file.

<Note>
  You need to replace `<hostname>` for `--redishost=<hostname>`with your own value to run this script.
</Note>

```bash theme={null}
sudo /opt/tyk-gateway/install/setup.sh --dashboard=1 --listenport=8080 --redishost=<hostname> --redisport=6379
```

What we've done here is told the setup script that:

* `--dashboard=1`: We want to use the Dashboard, since Tyk Gateway gets all it's API Definitions from the Dashboard service, as of v2.3 Tyk will auto-detect the location of the dashboard, we only need to specify that we should use this mode.
* `--listenport=8080`: Tyk should listen on port 8080 for API traffic.
* `--redishost=<hostname>`: Use Redis on your hostname.
* `--redisport=6379`: Use the default Redis port.

**Starting Tyk**

The Tyk Gateway can be started now that it is configured. Use this command to start the Tyk Gateway:

```bash theme={null}
sudo service tyk-gateway start
sudo service tyk-gateway enable
```

**Pro Tip: Domains with Tyk Gateway**

Tyk Gateway has full domain support built-in, you can:

* Set Tyk to listen only on a specific domain for all API traffic.
* Set an API to listen on a specific domain (e.g. api1.com, api2.com).
* Split APIs over a domain using a path (e.g. api.com/api1, api.com/api2, moreapis.com/api1, moreapis.com/api2 etc).
* If you have set a hostname for the Gateway, then all non-domain-bound APIs will be on this hostname + the `listen_path`.

[1]: https://packagecloud.io/tyk