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

# Restart a Maia runner

export const Runners = () => <>the <strong>Runners & Instances</strong> icon <span style={{
  whiteSpace: "nowrap"
}}><img src="/images/global-nav/runners-instances.png" width="20" height="20" style={{
  verticalAlign: "text-bottom",
  display: "inline",
  margin: "0 1px"
}} /></span></>;

export const m_runner = "Maia runner";

export const maia = "Maia";

export const RunnerMetadata = ({runnerType, platforms = []}) => {
  return <div style={{
    background: 'var(--colors-background-light, #f9fafb)',
    border: '1px solid var(--colors-border-default, #e5e7eb)',
    borderRadius: '12px',
    padding: '20px 28px',
    marginBottom: '28px'
  }}>
      <table style={{
    width: '100%',
    borderCollapse: 'collapse'
  }}>
        <tbody>
          <tr>
            <td style={{
    fontWeight: '600',
    paddingRight: '32px',
    paddingBottom: '14px',
    whiteSpace: 'nowrap',
    verticalAlign: 'middle',
    width: '180px'
  }}>Runner type</td>
            <td style={{
    paddingBottom: '14px',
    verticalAlign: 'middle'
  }}>{runnerType}</td>
          </tr>
          <tr>
            <td style={{
    fontWeight: '600',
    paddingRight: '32px',
    whiteSpace: 'nowrap',
    verticalAlign: 'middle'
  }}>Runner platform</td>
            <td style={{
    verticalAlign: 'middle'
  }}>
              <div style={{
    display: 'flex',
    flexWrap: 'wrap',
    gap: '8px'
  }}>
                {platforms.map((platform, i) => <span key={i} style={{
    background: '#dcfce7',
    color: '#15803d',
    border: '1px solid #bbf7d0',
    borderRadius: '9999px',
    padding: '3px 12px',
    fontSize: '0.85rem',
    fontWeight: '500',
    whiteSpace: 'nowrap'
  }}>
                    {platform} ✅
                  </span>)}
              </div>
            </td>
          </tr>
        </tbody>
      </table>
    </div>;
};

<RunnerMetadata runnerType={`${maia} Hybrid`} platforms={["AWS", "Azure", "Google Cloud", "Snowflake"]} />

You might need to restart your {m_runner} from time to time for any of the following reasons:

* {m_runner}s can sometimes crash or become unstable.
* You changed the {m_runner}'s configuration.
* You added a new certificate to be used for setting up a [proxy server](/docs/guides/customizing-runner-networking-and-connectivity).
* You added new [Python libraries](/docs/guides/optional-runner-parameters#loading-additional-python-libraries).
* You added new [third-party drivers](/docs/guides/uploading-external-drivers).
* To receive {m_runner} updates.

***

## Prerequisites

To restart a {m_runner} from the **Runners** list in {maia}, you must have the **Manage runners** [service](/docs/administration/account-roles#role-permissions) enabled for your user account.

<Note>
  There is no granular "restart {m_runner} only" permission. Users who need to restart {m_runner}s must have full **Manage runners** access. Alternatively, users with appropriate permissions in your {m_runner} provider (AWS, Azure, Google Cloud, or Snowflake) can restart {m_runner}s directly from the {m_runner} provider console without requiring **Manage runners** access in {maia}.
</Note>

***

## How to restart your Maia runner

You can restart your {m_runner} in one of two ways:

* From the [{m_runner}s](#restart-from-the-maia-runner-screen) screen in {maia}.
* From the cloud provider's control panel:

  * [AWS](#restart-an-aws-ecs-fargate-maia-runner)
  * [Azure](#restart-an-azure-maia-runner)
  * [Google Cloud](#restart-a-gke-maia-runner)
  * [Snowflake](#restart-a-snowflake-maia-runner)

  <Note>
    A changed {m_runner} deployment configuration may require a restart of the cloud provider service to take effect.
  </Note>

Read [Pause a {m_runner}](/docs/guides/pause-runner) for an alternative way of managing {m_runner}s that need restarting.

***

## Restart from the Maia runner screen

1. In the left navigation, click <Runners />. Then, select **Runners** from the menu.
2. Locate the {m_runner} you want to restart and click the three dots **...**.
3. Click **Restart runner**.
4. Click **Yes restart** to confirm.

This feature takes advantage of how a cloud provider will manage an installed {m_runner} service by ensuring that the required amount of {m_runner} instances (tasks/pods, depending on your deployment) are always started if any drop.

The **Restart runner** option sends a graceful shutdown request to all the instances (tasks/pods) contained within the {m_runner} service on the cloud provider. Each instance will complete any pipeline tasks currently in progress, or wait for any open transactions to complete, and then shut itself down. The {m_runner} service will then start up new, replacement instances.

Running pipelines will continue as normal. Any pipeline tasks that are sent to a {m_runner} that's currently restarting will be queued until the new service is back up and running. Your pipelines will be unaffected, though they may take a few minutes longer than normally expected for execution to complete.

Assuming that there are no running tasks, it usually takes a few minutes for a {m_runner} instance to shut down and a new instance to start back up. If you have multiple instances and one is working on a longer pipeline task or currently has an open transaction, then the other restarted {m_runner} instances will take on any new pipeline tasks.

***

## Restart an AWS ECS Fargate Maia runner

You will need access to your AWS account with the appropriate permissions.

To restart your AWS {m_runner}, follow these steps:

1. Log in to the [AWS console](https://aws.amazon.com/).
2. In the AWS console, type `Elastic Container Service` in the search bar, and select that service.
3. Locate the ECS service running your {m_runner}, and click **Update service**.
4. Select the latest task definition and click **Update**.

***

## Restart an Azure Maia runner

You will need access to your Azure account with the appropriate permissions.

There are two ways you can restart an Azure {m_runner}:

* The Azure Portal
* The Azure CLI

### Using the Azure Portal

To restart your {m_runner} using the Azure Portal, follow these steps:

1. Log in to the [Azure Portal](https://azure.microsoft.com/).
2. In the search bar at the top of the Azure Portal, enter "Container apps", and click the **Container Apps** link in the results menu.
3. Click your chosen container app from the list.
4. Click **Application** to display a context menu.
5. Click **Revisions and replicas**.
6. Click on the name of the intended **Active Revision**.
7. A panel to the right will appear. At the top of **Revision details**, click **Restart**.

### Using the Azure CLI

To restart your {m_runner}, you can open the Azure CLI either locally on your machine, or through the [Azure portal](https://azure.microsoft.com/).

Use the following command:

```
az containerapp revision restart --revision <REVISION_NAME> --resource-group <RESOURCE_GROUP_NAME> --subscription <SUBSCRIPTION_NAME>
```

For example, if you have a {m_runner} called `cloud-runner-dev` in a resource group called `cloud-runner-dev`, and your Azure subscription is called **Matillion Dev**, you are required to use the following command:

```
az containerapp revision restart --revision cloud-runner-dev --resource-group cloud-runner-dev --subscription "Matillion Dev"
```

***

## Restart a GKE Maia runner

You will need access to your Google Cloud account with the appropriate permissions, and `kubectl` configured for your GKE cluster.

To restart your GKE {m_runner}, run the following command, replacing `RELEASE_NAME` and `NAMESPACE` with the Helm release name and Kubernetes namespace used during deployment (both default to `matillion-agent`):

```bash theme={null}
kubectl rollout restart deployment/RELEASE_NAME-app -n NAMESPACE
```

Kubernetes will perform a rolling restart, bringing up new pods before terminating the old ones. Running pipelines will continue as normal — any tasks sent to the {m_runner} during the rollout will be queued until the new pods are ready.

***

## Restart a Snowflake Maia runner

You can restart the {m_runner} by suspending and resuming the [compute pool](https://docs.snowflake.com/en/developer-guide/snowpark-container-services/working-with-compute-pool) from within Snowflake. Suspending the compute pool will prevent the {m_runner} from being used by {maia}, and will stop all running tasks. Resuming the compute pool will make the {m_runner} available for use again.

1. From your Snowflake **Home** screen, click **Data Products** → **Apps**. You must be using the role that originally installed the application.

2. Locate **Matillion Data Productivity Cloud** in the list of apps, and click to select it. If you have multiple installs of the Native App, select the one you wish to restart.

3. Click the **Control Panel** tab.

4. Click **Suspend Compute Pool**, then click **Suspend** to confirm. This will put the pool into a **Stopping** state and change the {m_runner} status to **Suspending**.

   <Warning>
     This will suspend the compute pool and all {m_runner} instances that it supports. This will stay suspended until you actively click **Resume Compute Pool**.
   </Warning>

5. Wait for the {m_runner} to stop. This may take a few minutes.

6. When the {m_runner} is in a **Suspended** state, click **Resume Compute Pool**. This will put the pool into a **Starting** state and change the {m_runner} status to **Pending**.

7. Wait for the {m_runner} to start. This may take a few minutes.

   <Note>
     After the compute pool changes to an **Active** state, the {m_runner} status may remain as **Pending** for a few minutes before changing to **Running**.
   </Note>