Categorias
Sem categoria

Rodando Asp.Net Core no Apache em um CentOS 8

Usando a Digital Ocean, criamos uma VM CentOS 8, limpa, sem nenhum complemento.

Para acesso ao servidor criado, utilizaremos o PuTTY, um terminal com suporte a SSH que pode ser baixado em https://www.putty.org/.

Acessar PuTTY e em Host informar “root@IP_DO_SERVIDOR”. O IP do servidor será o fornecido pelo provedor de serviços (no nosso caso, Digital Ocean).

Ao informar a senha, estaremos logados e executaremos o primeiro comando, que será para atualização do sistema operacional (obtendo todos os updates disponíveis):
# yum update
Confirme com a letra Y sempre que solicitado.

Reinicie a VM com o seguinte comando:
# reboot
Alguns segundos depois, assim que a VM reiniciar, efetue novamente o processo de autenticação.

O próximo comando será para instalar o .Net Core 3.1 (o mais recente no momento desse post). Apenas a instalação do runtime (# dnf install aspnetcore-runtime-3.1 ) do framework é o suficiente para a execução das aplicações. Porém, optei por instalar o SDK (que já engloba o runtim), me dando a opção de criar aplicações para testes caso necessário:
# dnf install dotnet-sdk-3.1
Após a instalação, podemos executar o seguinte comando para verificar o funcionamento do dotnet e os pacotes instalados:
# dotnet –info

Após a instalação, executaremos a instalação do apache:
# yum -y install httpd mod_ssl
O comando whereis httpd pode ser útil para se identificar os diretórios onde o apache foi instalado e onde estão localizadas suas configurações.

Por padrão, os arquivos de configuração das aplicações rodadas pelo apache ficam no diretório /etc/httpd/conf.d/ e é onde iremos colocar o arquivo de configuração da nossa aplicação.
Como sugestão, utilize o editor nano, que pode ser instalado com o seguinte comando:
# sudo yum install -y nano

Para facilitar utilize o seguinte comando para entrar no diretório de configuração:
# cd /etc/httpd/conf.d/

O nome do arquivo de configurações será netcore-aplicacao.conf e será iniciado através do seguinte comando:
# nano netcore-aplicacao.conf

O arquivo de configuração que iremos criar terá a seguinte estrutura:

<VirtualHost *:*>
    RequestHeader set "X-Forwarded-Proto" expr=%{REQUEST_SCHEME}
</VirtualHost>

<VirtualHost *:80>
    ProxyPreserveHost On
    ProxyPass / http://127.0.0.1:5000/
    ProxyPassReverse / http://127.0.0.1:5000/
    ServerName www.aplicacao.com
    ServerAlias *.aplicacao.com
    ErrorLog /var/log/httpd/aplicacao-error.log
    CustomLog /var/log/httpd/aplicacao-access.log common
</VirtualHost>

Uma vez editado, o arquivo é salvo precionando CTRL + O, e em seguida dando ENTER. Para sair da edição, basta pressionar CTRL + X.

Com o arquivo criado, vamos executar o seguinte comando para verificar se as informações das configurações foram configuradas corretamente:
# sudo service httpd configtest

Alguns erros que podem ocorrer:
AH00526: relacionado a certificado. Para resolver basta remover o arquivo /etc/httpd/conf.d/ssl.conf.
AH00558: não é exatamente um problema, mas para resolver basta utilizar o editor nano e adicionar a linha ServerName localhost no arquivo /etc/httpd/conf/httpd.conf.

Concluídas as alterações nos arquivos do apache, hora de reiniciá-lo:
# sudo systemctl restart httpd
# sudo systemctl enable httpd

Nesse momento ao acessar o servidor por http seja IP ou domínio já apontando para esse server, já deve ser possível receber a mensagem de Service Unavailable.

O apache já redireciona todas as requisições da porta 80 para o endereço local com porta 5000.

Vamos então criar as configurações necessárias para que a aplicação seja executada na porta 5000 (estamos usando a porta padrão dos projetos Asp.Net Core).

Vamos iniciar a criação do arquivo com o seguinte comando:
# nano /etc/systemd/system/kestrel-aplicacao.service
O arquivo deverá ter uma estrutura similar a isso:

[Unit]
Description=Descrição da aplicação

[Service]
WorkingDirectory=/var/www/aplicacao
ExecStart=/usr/bin/dotnet /var/www/aplicacao/aplicacao.dll
Restart=always
RestartSec=10
KillSignal=SIGINT
SyslogIdentifier=aplicacao-log
User=apache
Environment=ASPNETCORE_ENVIRONMENT=Production 

[Install]
WantedBy=multi-user.target

Em seguida, vamos habilitar o serviço, iniciá-lo e verificar o status do serviço, respectivamente com os seguintes comandos:
# systemctl enable kestrel-aplicacao.service
# systemctl start kestrel-aplicacao.service
# systemctl status kestrel-aplicacao.service

Ao executar o comando do status notará um erro (code=exited, status=200/CHDIR) devido a inexistência dos arquivos.

Faça a transferência dos arquivos para o diretório /var/www/aplicacao. Uma forma fácil é utilizando o FileZilla, selecionando o tipo de conexão SFTP, informando o IP, usuário e senha de acesso ao servidor.

Após o envio dos arquivos, basta reiniciar o serviço:
# systemctl restart kestrel-aplicacao.service

PAREI A EDIÇÃO DO POST E CONFIGURAÇÃO DA VM AQUI.

Fonte:
https://docs.microsoft.com/pt-br/aspnet/core/host-and-deploy/linux-apache?view=aspnetcore-3.1

Categorias
Sem categoria

Criar nova base no MySQL utilizando Ubuntu

Considerando tudo instalado e rodando, basta acessar o ternimal e digitar:

mysql -h localhost -u root -p

Será solicitada a senha de acesso.

Agora é digitar o comando de criação do banco:

CREATE DATABASE nome_da_base

Categorias
Angular Firebase

Autenticação com Firebase em uma aplicação Angular

Rapidamente e resumidamente:

No Firebase

1 – Acessar o site do firebase.

2 – Criar um novo projeto (caso não exista).

3 – Adicionar um aplicativo web, dando um apelido e um identificador único a ele.

4 – Copiar o trecho de código fornecido no momento da criação do aplicativo, semelhante a esse:

  firebaseConfig: {
    apiKey: "123456",
    authDomain: "sua-aplicacao.firebaseapp.com",
    projectId: "sua-aplicacao",
    storageBucket: "sua-aplicacao.appspot.com",
    messagingSenderId: "123456",
    appId: "123456",
    measurementId: "123456"
  }
No projeto Angular

1 – Abrir o seu arquivo de configurações de ambiente “environment.ts” e “environment.prod.ts” (ou de acordo com sua estratégia de distribuição) e cole o código copiado anteriormente.

2 – Adicione ao projeto o pacote do firebase com o seguinte comando: ng add @angular/fire

3 – Atualize as ferramentas do firebase com o seguinte comando: npm install -g firebase-tools

4 – No arquivo app.module.ts, faça as importações “import { AngularFireModule } from ‘@angular/fire’;” e “import { AngularFireAuthModule } from ‘@angular/fire/auth’;”.

5 – Ainda no arquivo app.module.ts, dentro de “imports [ ]” adicione AngularFireModule.initializeApp(environment.firebaseConfig) e AngularFireAuthModule.

Daqui pra frente são configurações relacionadas a navegação e login, envolvendo nossos arquivos HTML e TS.

Continua…

Categorias
Linux MySQL Ubuntu

Criando base do MySQL pelo console do Ubuntu

Inicialmente, digitar o seguinte comando para entrar no MySQL:

mysql -h localhost -u root -p

Após informar a senha, entramos no console do MySQL: mysql>

Agora é executar o comando de criação da base de dados:

CREATE DATABASE banco_de_dados;

Agora vamos usar o seguinte comando para alternar para a nova base de dados:

use banco_de_dados;

Este comando é usado para entrar na base, onde será possível executar os comandos para criação, alteração e exclusão da estrutura de tabelas e campos, além claro de ser possível a consulta, alteração exclusão dos dados da base.

Por último, se necessário, podemos atribuir as permissões a algum usuário à essa base, utilizando o comando grant: 

GRANT ALL PRIVILEGES ON base_de_dados TO 'usuario'@'localhost';

E é só isso!

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
Sem categoria

Instalando o Flutter

A instalação que será aqui apresentada será direcionada ao ambiente Windows.

Preparando o pacote

O primeiro passo é baixar o pacote no seguinte link: https://storage.googleapis.com/flutter_infra/releases/stable/windows/flutter_windows_v1.12.13+hotfix.5-stable.zip

Depois vamos descompactar o pacote em um diretório temporário, como por exemplo em “c:\temp\flutter”.

Iniciando a instalação

Iniciamos acessando o diretório descompactado e executando o seguinte comando: “c:\temp\flutter\flutter doctor”. Esse comando irá validar se todas as dependências já estão instaladas.

Mais detalhes podem ser encontrados no link https://flutter.dev/docs/get-started/install/windows

Obrigado e 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.