Categoria: .Net Core

Categorias
.Net Core

Rodar uma aplicação Asp.Net Core no NGINX e Ubuntu

Primeiramente vamos iniciar o processo copiando o pacote do projeto para o diretório /home/ubuntu/apps/sample.
Isso pode ser feito através de um programa de ftp ou qualquer outro meio.

Depois disso vamos então editar o arquivo de configurações padrão do nginx para gerenciar o redirecionamento da aplicação:
nano /etc/nginx/sites-available/default

O arquivo deverá contar com essa estrutura:
server {
listen 80;
server_name {endereco_da_aplicacao} # todas as variações do endereço (com www, sem www) devem ser inseridas com espaço entre elas);
root /home/ubuntu/apps/{your-folder-name};
location / {
proxy_pass http://localhost:5000;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection keep-alive;
proxy_set_header Host $host;
proxy_cache_bypass $http_upgrade;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}

Após isso basta iniciar o serviço:
service nginx restart

Com esse comando é possível iniciar o serviço se ele estiver parado:
service nginx start

Agora é criar o serviço da aplicação. Faremos isso iniciando a criação do arquivo necessário:
nano /etc/systemd/system/{your-service-name}.service

A sintaxe do arquivo deve ser similar a isso:

[Unit]
Description=Descrição da aplicação
[Service]
WorkingDirectory=/home/ubuntu/apps/diretorio_da_aplicacao
ExecStart=/usr/bin/dotnet /home/ubuntu/apps/diretorio_da_aplicacao/NomeDaDllDoProjeto.dll
Restart=always
RestartSec=10
KillSignal=SIGINT
SyslogIdentifier=dotnet-example
User=www-data
Environment=ASPNETCORE_ENVIRONMENT=Production
Environment=DOTNET_PRINT_TELEMETRY_MESSAGE=false
Environment=ASPNETCORE_URLS=http://localhost:5000
[Install]
WantedBy=multi-user.target

Agora precisamos habilitar o serviço:
systemctl enable {your-service-name}.service

Em seguida precisamos iniciar o serviço:
systemctl start {your-service-name}.service

É possível verificar o status do serviço
systemctl status {your-service-name}.service

Para acompanhar a execução da aplicação e verificar logs, execute esse comando:
journalctl -fu {your-service-name}.service

Categorias
.Net Core

Executando automaticamente o Migration em uma aplicação .Net Core com MySql

O objetivo desse tutorial é: permitir que uma aplicação .Net Core, conectada a uma base MySql, possa automaticamente executar o Migration no carregamento da aplicação. Isso facilita a atualização da base de dados da aplicação independente do ambiente em que for executada.

Mas lembre-se: use com moderação. É sempre bom possuir um processo de backup antes de qualquer atualização de bases de produção, ainda mais em um processo automatizado.

Começamos com um projeto Asp.NET Core MVC com Identity (o template encontrato no Visual Studio 2019). Com isso já temos um contexto, entidades do Identity e toda a estrutura da aplicação preparada para realizarmos nossos testes e validarmos a solução.

Instalar o pacote pelo PackageConsole utilizando o comando “install-package Pomelo.EntityFrameworkCore.MySql“. Esse será o pacote necessário para todo o processo com o MySql.

No método ConfigureServices (arquivo Startup.cs), alterar a configuração de tipo de banco de dados de “UseSqlServer” para “UseMySql“, ficando dessa forma:

services.AddDbContext<ApplicationDbContext>(options =>
 options.UseMySql(Configuration.GetConnectionString("DefaultConnection")));

No arquivo “appSettings.json“, alterar a string de conexão “ConnectionStrings.DefaultConnection” para a string de conexão do MySql (“Server=localhost;Database=db;Uid=user;Pwd=pass;“). Observando que a base no MySql já deve estar criada caso o usuário utilizado na conexão não tenha permissões para tal ação.

A última configuração que faremos está relacionada ao arquivo “Program.cs“. Vamos substituir os 2 métodos da classe (“Main” e “CreateHostBuilder“, considerando o padrão do template do VS2019 com .Net Core 3.x).
O código que será utilizado na substituição é esse:

        public static void Main(string[] args)
        {
            var host = CreateHostBuilder(args).Build();

            using (var scope = host.Services.CreateScope())
            {
                var services = scope.ServiceProvider;

                try
                {
                    var context = services.GetRequiredService<ApplicationDbContext>();
 // Ajustar o nome do contexto da aplicação
                    context.Database.Migrate();
                }
                catch (Exception ex)
                {
                    var logger = services.GetRequiredService<ILogger<Program>>();
                    logger.LogError(ex, "Erro ao atualizar a base de dados.");
                }
            }

            host.Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                });

Com todas as configurações feitas, bastam apenas mais 2 ações:
– Remover o diretório “Migrations” (que fica no diretório “Data”);
– E adicionar um novo migration através do PackageConsole: add-migration v1.

O nove da versão “v1” é apenas uma sugestão. Mas o que importa é que agora, a executar a aplicação e se conectar na base MySql, essas configurações permitirão que automaticamente sejam realizadas os migrations pendentes na base de dados.

O mesmo acontecerá quando houverem mudanças futuras no modelo de dados da aplicação (futuras versões v2, v3 etc.).

Bom é só isso. Até a próxima.

Categorias
.Net Core

Habilitar o auto migration no carregamento de uma aplicação .Net Core

O Migration existente no .Net FullFramework possui alguns recursos que até no momento desse post não estão presentes no .Net Core.

Um desses recursos é o auto migration, que facilita e automatiza a atualização da base de dados em produção. Claro, isso deve seguir alguns procedimento de homologação antes e um processo de rollback em caso de falhas (o que poderia ocorrer com uma atualização manual).

Para habilitar o auto migration no .Net Core serão necessários poucas linhas de código. Isso vai garantir a aplicação automática das mudanças no banco de dados assim que a aplicação for carregada.

Vamos considerar uma aplicação MVC Core, iniciada do zero, apenas ativando a autenticação individual para que já tenhamos a estrutura básica da aplicação web e um contexto pré-configurado.

Serão necessárias apenas algumas configurações no arquivo appsettings.json para que sejam configurados os dados de acesso ao banco de dados.

Começamos alterando o arquivo Program.cs, importando os seguintes namespaces (apenas ajustando o nome do contexto):

using Microsoft.Extensions.DependencyInjection;
using Microsoft.EntityFrameworkCore;
using Microsoft.AspNetCore;

Continuamos alterando os métodos padrão para o seguinte código:

public static void Main(string[] args)
{
    var host = CreateWebHostBuilder(args).Build();
    using (var scope = host.Services.CreateScope())
    {
        var services = scope.ServiceProvider;
        try
        {
            var context = services.GetRequiredService<NOME_DO_CONTEXTO_DA_APLICACAO>();
            context.Database.Migrate();
        }
        catch (Exception ex)
        {
            var logger = services.GetRequiredService<ILogger<Program>>();
            logger.LogError(ex, "Erro ao atualizar banco.");
        }
    }

    host.Run();
}

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
    WebHost.CreateDefaultBuilder(args)
        .UseStartup<Startup>();

Com isso, basta realizar as alterações e criação de novas entidades, executar o comando Add-Migration e ao executar a aplicação verá que a atualização ocorrerá automaticamente.

Até a próxima.

Categorias
.Net Core

Habilitando Cors em API .Net Core

O primeiro passo é instalar o pacote Cors:

Install-Package Microsoft.AspNetCore.Cors

No método ConfigureServices do arquivo startup.cs, adicione a seguinte linha:

services.AddCors(options => options.AddPolicy("CorsPolicy", builder =>
            {
                builder.WithOrigins("*").AllowAnyMethod().AllowAnyHeader();
            })); // Isso deve estar antes de AddMvc

Por último, no método Configure do arquivo startup.cs, adicione o seguinte código:

app.UseCors("CorsPolicy");

Simples assim!

Categorias
.Net Core

Identity no .Net Core: configurando a política de senhas.

Ao criar um projeto utilizando .Net Core, que utilize o Identity na estrutura padrão do template (MVC nesse exemplo), verá que por padrão a complexidade de senha exige caracteres especiais, números entre outras configurações.

Em alguns cenários essa configuração padrão não é necessária.

Vamos considerar as seguintes políticas para uma senha mais simples:
– Sem obrigatoriedade de dígito numérico;
– Tamanho mínimo de 6 caracteres na senha;
– Não exigir caracteres alfanuméricos;
– Não exigir letra maiúscula;
– Não exigir letra minúscula.

Para essas configurações, vamos utilizar o código abaixo no arquivo Startup.cs:

public void ConfigureServices(IServiceCollection services)
{
    // Outras configurações existentes no método...

    // Configurações da política de senha:
    services.Configure<IdentityOptions>(options =>
    {
        options.Password.RequireDigit = false;
        options.Password.RequiredLength = 6;
        options.Password.RequireNonAlphanumeric = false;
        options.Password.RequireUppercase = false;
        options.Password.RequireLowercase = false;
    });
}

O exemplo acima configura a aplicação para os requisitos de complexidade de senha citados anteriormente.

Até a próxima.