MSDN Documentation - .NET Web Deployment

Deploying .NET Web Applications on macOS

This section provides comprehensive guidance on deploying your .NET web applications to macOS environments. macOS offers a robust and developer-friendly platform for hosting and managing web services.

Prerequisites

Before you begin, ensure you have the following installed:

.NET SDK (version matching your application's target framework)
Homebrew (recommended package manager for macOS)

Deployment Methods

Several approaches can be used to deploy .NET web applications on macOS:

1. Using the .NET CLI

The .NET CLI provides powerful tools for publishing and running your applications directly. This is often the simplest method for development and small-scale deployments.

Publish your application: Navigate to your project directory in the terminal and run the following command:
```
dotnet publish -c Release -o ./publish
```
This command publishes your application in Release configuration to a folder named publish.
Run your application: Navigate to the publish directory and execute:
```
dotnet YourAppName.dll
```
Replace YourAppName.dll with the actual name of your application's DLL file.

2. Hosting with Kestrel behind a Reverse Proxy

For production environments, it's common practice to run your .NET application using Kestrel (the built-in cross-platform web server) behind a reverse proxy like Nginx or Apache. This provides benefits such as load balancing, SSL termination, and static file serving.

Using Nginx:

Install Nginx using Homebrew:

brew install nginx

Configure Nginx to proxy requests to your Kestrel server. A sample Nginx configuration file (e.g., /usr/local/etc/nginx/servers/your-app.conf) might look like this:

server {
    listen 80;
    server_name yourdomain.com;

    location / {
        proxy_pass http://localhost:5000; # Assuming Kestrel is running on port 5000
        proxy_redirect off;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Start Nginx and reload its configuration.

3. Containerization with Docker

Docker offers an excellent way to package your .NET application and its dependencies into a portable container. This ensures consistency across different environments.

Create a Dockerfile in your project's root directory:

FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build AS publish
WORKDIR /app
COPY . .
RUN dotnet publish "YourAppName.csproj" -c Release -o /app/publish

FROM mcr.microsoft.com/dotnet/aspnet:7.0
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "YourAppName.dll"]

Build the Docker image:

docker build -t your-app-image .

Run the Docker container:

docker run -d -p 8080:80 your-app-image

Managing Your Application

For long-running services, consider using a process manager like pm2 to keep your .NET application running, restart it on crashes, and manage logs.

Install pm2 globally:

npm install pm2 -g

Start your application with pm2:

dotnet publish -c Release -o ./publish
cd publish
pm2 start YourAppName.dll --name "my-dotnet-app"

Troubleshooting Common Issues

Port Conflicts: Ensure the port your application is trying to use is not already in use.
Permissions: Verify that the user running the application has the necessary file system permissions.
Environment Variables: Use environment variables for configuration settings, especially in production.

For more advanced deployment scenarios, including continuous integration and continuous delivery (CI/CD), refer to the dedicated sections in our documentation.