How to host asp.net core wep api inside docker container

Looks like the generated dockerfile form vs don't reference the dotnet:2.1-aspnetcore-runtime and dotnet:2.1-sdk.

Try to these steps

Add below Dockerfile to your solution folder

FROM microsoft/dotnet:2.1-sdk AS build-env
WORKDIR /build
COPY . /build

#Restore
RUN dotnet restore ./HelloApi.sln

RUN dotnet publish ./HelloApi/ -o /publish --configuration Release

# Build runtime image
FROM microsoft/dotnet:2.1-aspnetcore-runtime
WORKDIR /app
COPY --from=build-env /publish/ .
ENTRYPOINT ["dotnet", "WebApp.dll"]

Build it

docker build -t app1 .

Run it

docker run -p 8080:80 --name appcontainer1 app1

Test it

Browse to http://localhost:8080

It looks like the tutorials you have been following are all for .NET Core 2.0 but your project is using .NET Core 2.1.

As you (probably) know, the first line in the Dockerfile defines what image to run your application on. In your case you microsoft/aspnetcore. If you take a look at the Docker Hub page for the microsoft/aspnetcore image you will see it says:

Latest images for 2.1 and newer are now available on microsoft/dotnet. See this link for more details about migrating to 2.1.

Clicking on that link takes you to the Docker Hub page for the microsoft/dotnet image, which supports .NET Core 2.1.

So, as stated in another answer, you need to change your Dockerfile to reference a different image that has the .NET Core 2.1 runtime installed. You could just change the first line to:

FROM microsoft/dotnet

which could use an image that has the .NET Core 2.1 SDK installed, but that image would be overkill if you are planning to deploy the image to production.

Current practice is to use multi-stage Dockerfiles to perform the build, test and publish steps inside the container. You can read about this here. This allows you to use a different image base to build and test your application but only use the smaller runtime image for the final production image.

Take a look at some of the .NET Core Docker Samples to see how to do this.

Just be mindful when you are looking for tutorials that they use the newer .NET Core 2.1 as the base image, or ensure you create any applications using the same .NET Core version as the tutorial.

Hope that helps.

Dockerfile

FROM mcr.microsoft.com/dotnet/core/aspnet:2.2-stretch-slim AS base
WORKDIR /app

FROM mcr.microsoft.com/dotnet/core/sdk:2.2-stretch AS build
COPY ./SampleWebApi.csproj /SampleWebApi/
RUN dotnet restore ./SampleWebApi/SampleWebApi.csproj
COPY . ./SampleWebApi/
WORKDIR /SampleWebApi/
RUN dotnet build "SampleWebApi.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "SampleWebApi.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "SampleWebApi.dll"]

docker-compose.yml

version: '3.5'

services:
    sample-web-api:
        build: SampleWebApi/
        restart: always
        ports:
            - "7000:80"

Run the below command

docker-compose build
docker-compose up

Sample web API code along with Dockerfile on Github

I've successfully hosted dotnet core 2.1 WebAPI applications in docker using Kestrel web-server with the microsoft/dotnet image and tags of 2.1-sdk and dotnet:2.1-aspnetcore-runtime for build and runtime respectively in multi-stage build e.g.

FROM microsoft/dotnet:2.1-aspnetcore-runtime AS base
FROM microsoft/dotnet:2.1-sdk AS build

Hope this helps.