web-dev-qa-db-fra.com

Comment exécuter un site .NET Core MVC sur une instance AWS Linux

Je souhaite exécuter un site Web .NET Core MVC à partir d'une instance AWS Amazon Linux AMI.

Voici les mesures que j'ai prises jusqu'à présent:

  1. Créez un modèle Application Web principale ASP.NET Core (.NET Core) - C # - Projet d'application Web MVC dans Visual Studio 2015. Compilez et exécutez l'application dans IIS Express. Aucune modification apportée à aucune configuration (web.confg, project.json, etc.).
  2. Téléchargez la solution d'application Web complète sur GitHub.
  3. Lancez une instance Amazon Linux AMI (2016.03.2). Security Group a un accès "tout le trafic" ouvert pour le moment pour plus de simplicité.
  4. Utilisez PuTTY pour SSH dans une instance Linux. Connectez-vous avec ec2-user.
  5. Mettre à jour l'instance Sudo yum update -y
  6. Installez libunwindSudo yum install libunwind -y
  7. Installez gettextSudo yum install gettext -y
  8. Installez .NET Corecurl -sSL https://raw.githubusercontent.com/dotnet/cli/rel/1.0.0-preview1/scripts/obtain/dotnet-install.sh | bash /dev/stdin --version 1.0.0-preview1-002702 --install-dir ~/dotnet
  9. Lien Sudo ln -s ~/dotnet/dotnet /usr/local/bin
  10. Installer .NET Version Manager (DNVM)curl -sSL https://raw.githubusercontent.com/aspnet/Home/dev/dnvminstall.sh | DNX_BRANCH=dev sh && source ~/.dnx/dnvm/dnvm.sh
  11. Exécuter la commande source /home/ec2-user/.dnx/dnvm/dnvm.sh
  12. Installer .NET Execution Environment (DNX)dnvm upgrade -r coreclr
  13. Installez libuv à utiliser par KestrelSudo yum install automake libtool wget -y wget http://dist.libuv.org/dist/v1.8.0/libuv-v1.8.0.tar.gz tar -zxf libuv-v1.8.0.tar.gz cd libuv-v1.8.0 Sudo sh autogen.sh Sudo ./configure Sudo make Sudo make check Sudo make install Sudo ln -s /usr/lib64/libdl.so.2 /usr/lib64/libdl Sudo ln -s /usr/local/lib/libuv.so.1.0.0 /usr/lib64/libuv.so
  14. Installez GitSudo yum install git -y
  15. Créez un répertoire dans le répertoire '/ home/ec2-user' pour l'application. Déplacer vers ce répertoire. mkdir director-name cd directory-name
  16. Cloner une application Web avec Git git config user.name "myUserName" git config user.email "myEmail" git clone https://github.com/username/repositoryname.git
  17. Déplacer vers le répertoire 'projet' cd solution-name/src/web-project-name.
  18. Restaurer les packages dotnet restore
  19. Construire l'application dotnet build
  20. Lancer l'application dotnet run

À ce stade, je vois ce qui suit dans le terminal:

Vous écoutez maintenant sur: http: // localhost: 5000

J'essaie de frapper le DNS/IP AWS avec le port 5000 étiqueté à la fin (http: // aws-ip-or-dns: 5000), mais je ne reçois aucune réponse.

Je sais que Docker et Mono sont des outils que je peux utiliser, mais je préférerais que cette approche fonctionne.

Les scripts que j'ai utilisés pour installer .NET Core, DNVM et DNX sont une combinaison des instructions CentOS et Ubuntu à partir de ces liens:

  1. https://docs.asp.net/fr/latest/getting-started.html
  2. https://www.Microsoft.com/net/core#centos
  3. https://docs.asp.net/fr/1.0.0-rc1/getting-started/installing-on-linux.html

Disclaimer Je ne connais pas très bien Linux. Il est juste de dire que je ne comprends pas certaines des commandes que je lance. Mais je suis ici pour apprendre!

Question: Que dois-je faire pour obtenir un modèle d'application Web .NET Core exécutant un environnement AWS Amazon Linux?

(J'imagine qu'il me manque quelque chose lors de la configuration du serveur HTTP)

J'ai besoin de plus de réputation pour publier plus de deux liens, donc si quelqu'un veut éditer, je l'apprécierais.}

linuxamazon-ec2asp.net-core-mvckestrel-http-server
16
Bruno L.

Pour ceux qui ont besoin de mettre à jour ce qui précède pour la mise à jour Microsoft.NETCore.App 1.0.1 de septembre 2016, les instructions https://www.Microsoft.com/net/core#centos ont fonctionné pour moi:

curl -sSL -o dotnet.tar.gz https://go.Microsoft.com/fwlink/?LinkID=827529
Sudo mkdir -p /opt/dotnet && Sudo tar zxf dotnet.tar.gz -C /opt/dotnet
Sudo rm /usr/local/bin/dotnet
Sudo ln -s /opt/dotnet/dotnet /usr/local/bin

Par la suite, exécuter dotnet --info donne:

.NET Command Line Tools (1.0.0-preview2-003131)

Product Information:
 Version:            1.0.0-preview2-003131
 Commit SHA-1 hash:  635cf40e58

Runtime Environment:
 OS Name:     amzn
 OS Version:  2016.09
 OS Platform: Linux
 RID:         amzn.2016.09-x64

Après cela, j'ai supprimé mon project.lock.json et exécuté un dotnet restore.

Je ne pouvais pas faire fonctionner un dotnet run directement car mon RID n'était pas connu, mais utiliser une Dockerfile avec Microsoft/dotnet:onbuild et cette section de mon project.json fonctionnaient:

"runtimes": {
    "debian.8-x64" : {}
},
1
user326608

Si vous utilisez Opswork (ou Chef), vous pouvez utiliser la recette suivante de Chef https://supermarket.chef.io/cookbooks/dotnetcore pour installer un noyau de réseau de points sur AWS Linux, en supposant que vous ayez téléchargé le fichier a fichier en utilisant le fichier de publication dotnet dans un compartiment S3.
Le calque JSON a un JSON qui porte le nom abrégé de l’application, par exemple.

{
  myapp {}
}

# The recipe to install
# 1) Figure which App needs to be installed using JSON in Opsworks layer
# 2) Get the Zip file from S3 and Unzip into /usr/bin/myapp/publish
# 3) Create bash file to start
# 4) Start the app 

    apps = search(:aws_opsworks_app)
    apps.sort_by { |v| v["shortname"] }.each do |app|
        appname = app["shortname"]
        app_source = app["app_source"]
        bucket, remote_path = OpsWorks::SCM::S3.parse_uri("#{app_source['url']}")
        filename = remote_path.split("/")[-1]
        extn = File.extname  filename
        if (!node["#{appname}"].nil? && extn == '.Zip')
            apppath = "/usr/bin/#{appname}"
            dotnetapp = app["environment"]["dotnetapp"]
            aspnetcore_environment = app["environment"]["aspnetcore_environment"]
            Chef::Log.info("App dotnet Name:#{app[:environment][:dotnetapp]}")
            Chef::Log.info("Enviroment:#{aspnetcore_environment}")


            app_checkout = ::File.join(Chef::Config["file_cache_path"], app["shortname"])

            package = "#{app_checkout}/#{filename}"

# Use https://github.com/awslabs/opsworks-windows-demo-cookbooks or any s3_file recipe to download the Zip file
# if you copy the opsworks-windows-cookbooks you will to modify the recipe a little to work on aws linux
            opsworks_scm_checkout app["shortname"] do
                destination      app_checkout
                repository       app_source["url"]
                user             app_source["user"]
                password         app_source["password"]
                type             app_source["type"]
                ssh_key          app_source["ssh_key"]
                revision         app_source["revision"]
            end


            directory "#{apppath}" do
            end

            execute 'unzip package' do
                command "unzip -o #{app_checkout}/#{filename} -d #{apppath}"

            end

            # create a sysvint sh file to manage dotnet service 
            initd_directory = "/etc/init.d"

            intd_file = File.join(initd_directory, app["shortname"])

            template intd_file do
                mode "744"
                source 'file.sh.erb'
                variables(
                    :service_name => app["shortname"],
                    :dotnetapp => "#{dotnetapp}",
                    :apppath => "#{apppath}/publish"
                )
            end
            execute "start service #{dotnetapp}" do
                command ".#{initd_directory}/#{appname} start"
                environment ({"ASPNETCORE_ENVIRONMENT" => "#{aspnetcore_environment}"})
            end
            Chef::Log.info("End Install #{appname}")
        end
    end

# The ERB Template:

#!/bin/bash
#
# description: <%= @service_name %>
#

# Get function from functions library
. /etc/init.d/functions
#
# Start the service <%= @service_name %>
#
start() {
        initlog -c "echo -n Starting dotnet <%= @service_name %> server: "
        cd <%= @apppath %>
        Nohup dotnet <%= @dotnetapp %> /dev/null 2>&1 &
        ### Create the lock file ###
        touch /var/lock/subsys/<%= @service_name %>
        success $"<%= @service_name %> server startup"
        echo
}

# Restart the service <%= @service_name %>
stop() {
        initlog -c "echo -n Stopping dotnet <%= @service_name %> server: "
        killproc dotnet
        ### Now, delete the lock file ###
        rm -f /var/lock/subsys/<%= @service_name %>
        echo
}

### main logic ###
case "$1" in
  start)
        start
        ;;
  stop)
        stop
        ;;
  status)
        status dotnet
        ;;
  restart|reload|condrestart)
        stop
        start
        ;;
  *)
        echo $"Usage: $0 {start|stop|restart|reload|status}"
        exit 1
esac

exit 0
0
Haroon

Si vous exécutez votre instance AWS en mode VPC et que le groupe de sécurité ne dit pas que sa règle entrante contient "Tout le trafic" et que Source correspond à "Partout", ou s'il indique que "règle personnalisée TCP", Le port est 5000 et la source est "Partout", il ne vous permettra pas de vous connecter à ce port . En mode VPC, tous les ports entrants sont fermés par défaut et vous devez les autoriser explicitement avec certains groupes de sécurité prédéfinis ou propres.

0
Computer Mage