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

# Run a .NET App

Getting an application running on Fly.io is essentially working out how to package it as a deployable image. Once packaged, it can be deployed to the Fly.io platform.

In this guide we’ll learn how to deploy a [.NET](https://dotnet.microsoft.com/) application on Fly.io.

## *Generate the .NET Application*

For our example, we will create a simple "hello world" application using the default web template in .NET. We assume that you have already installed [.NET](https://dotnet.microsoft.com/en-us/download).

Once .NET is installed, we can create a new project by running the following command:

<CodeGroup>
  ```bash cmd theme={null}
  dotnet new web --name hellodotnet
  ```

  ```output output theme={null}
  The template "ASP.NET Core Empty" was created successfully.

  Processing post-creation actions...
  Restoring \hellodotnet\hellodotnet.csproj:
  Determining projects to restore...
  Restored \hellodotnet\hellodotnet.csproj (in 69 ms).
  Restore succeeded.
  ```
</CodeGroup>

## *Running the Application*

In the new application folder, execute the command `dotnet run` to initiate the application:

<CodeGroup>
  ```bash cmd theme={null}
  dotnet run
  ```

  ```output output theme={null}
  Building...
  Now listening on: http://localhost:5162
  Application started. Press Ctrl+C to shut down.
  Hosting environment: Development
  ```
</CodeGroup>

This command will start the "hellodotnet" application, and you will be able to access it locally using the address provided in the output.

Now, let's proceed to deploy this application to Fly.

## *Install Flyctl and Login*

We are ready to start working with Fly.io, and that means we need `flyctl`, our CLI app for managing apps on Fly.io. If you've already installed it, carry on. If not, hop over to [our installation guide](/flyctl/install). Once that's installed you'll want to [log in to Fly.io](/getting-started/sign-up-sign-in).

## *Launch the app on Fly*

Each Fly App needs a `fly.toml` file to tell the system how we'd like to deploy it.
That file can be automatically generated with the command `flyctl launch` command. This command will also generate a Dockerfile for deployment.

<CodeGroup>
  ```bash cmd theme={null}
  fly launch
  ```

  ```output output theme={null}
  Creating app in \fly\guides\hellodotnet
  Scanning source code
  Detected a .NET app
  ? Choose an app name (leave blank to generate one): hellodotnet
  ? Select Organization: demo (demo)
  ? Select region: ord (Chicago, Illinois (US))
  App will use 'ord' region as primary
  Created app 'hellodotnet' in organization 'demo'
  Admin URL: https://fly.io/apps/hellodotnet
  Hostname: hellodotnet.fly.dev
  ? Would you like to set up a Postgresql database now? No
  ? Would you like to set up an Upstash Redis database now? No
  Wrote config file fly.toml
  ? Would you like to deploy now? Yes

  Deploying hellodotnet
  ...
  ```
</CodeGroup>

That's it! Run `fly apps open` to see your deployed app in action.

Try a few other commands:

* `fly logs` - Tail your application logs
* `fly status` - App deployment details
* `fly deploy` - Deploy the application after making changes

## *Inside `fly.toml`*

The `fly.toml` file now contains a default configuration for deploying your app. In the process of creating that file, `flyctl` has also created a Fly-side application slot of the same name, "hellodotnet". If we look at the `fly.toml` configuration file we can see the name in there:

```toml theme={null}
app = "hellodotnet"
primary_region = "ord"

[http_service]
  internal_port = 8080
  force_https = true
  auto_stop_machines = true
  auto_start_machines = true
  min_machines_running = 0
  processes = ["app"]
...
```

The `flyctl` command will always refer to this file in the current directory if it exists, specifically for the `app` name/value at the start. That name will be used to identify the application to the Fly.io platform.

The rest of the file contains settings to be applied to the application when it deploys.

## Deploying to Fly.io

To deploy changes to your app, just run just run:

```bash theme={null}
fly deploy
```

This will lookup our `fly.toml` file and get the app name `hellodotnet` from there.

Then `flyctl` will start the process of deploying our application to Fly.io using the Dockerfile. Flyctl will return you to the command line when it's done.

## *Viewing the Deployed App*

If you want to find out more about the deployment. The command `fly status` will give you all the essential details.

<CodeGroup>
  ```bash cmd theme={null}
  fly status
  ```

  ```output output theme={null}
  App
    Name     = hellodotnet
    Owner    = personal
    Hostname = hellodotnet.fly.dev
    Image    = hellodotnet:deployment-01H4MDR3GVFX20X5DNVZS4BPWK
    Platform = machines

  Machines
  PROCESS ID              VERSION REGION  STATE   CHECKS  LAST UPDATED
  app     91857500000083  1       ord     started         2023-07-06T01:49:28Z
  app     e2865100000086  1       ord     stopped         2023-07-06T01:50:04Z
  ```
</CodeGroup>

## *Connecting to the App*

The quickest way to browse your newly deployed application is with the `flyctl apps open` command.

<CodeGroup>
  ```bash cmd theme={null}
  flyctl apps open
  ```

  ```output output theme={null}
  Opening https://hellodotnet.fly.dev/
  ```
</CodeGroup>

Your browser will be sent to the displayed URL.

## *Bonus Points*

If you want to know what IP addresses the app is using, try `fly ips list`:

<CodeGroup>
  ```bash cmd theme={null}
  fly ips list
  ```

  ```out out theme={null}
  VERSION IP                      TYPE            REGION  CREATED AT 
  v6      2a09:8280:1::69:37fd    public          global  18m55s ago
  v4      66.241.125.223          public (shared)
  ```
</CodeGroup>

## Arrived at Destination

You have successfully built, deployed, and connected to your first .NET web application on Fly.io.