MySQL

Utilizando Choices no Django ORM

Na construção de um formulário, há casos em que precisamos de um campo para armazenar determinadas opções para um atributo. Um exemplo claro deste caso é o armazenamento do sexo de um usuário, que só deve permitir uma determinada lista de opções (masculino, feminino, outro).
Para estes casos, o Django ORM permite que criemos uma lista com as possíveis opções que deverão ser selecionadas, evitando que o usuário possa digitar qualquer valor naquele campo.
Sendo assim, neste artigo veremos como trabalhar com choices no Django ORM.

Criando choices no models.py

Para criar uma lista de possíveis opções no Django ORM, precisamos definir quais serão estas opções e a qual chave ela pertence. Por exemplo, se quisermos criar uma lista de opções para o campo sexo, determinamos o seguinte conteúdo no arquivo models.py do nosso projeto:

class Cliente(models.Model):
    SEXO_CHOICES = (
        ("F", "Feminino"),
        ("M", "Masculino"),
        ("N", "Nenhuma das opções")
    )

    nome = models.CharField(max_length=100, null=False, blank=False)
    sexo = models.CharField(max_length=1, choices=SEXO_CHOICES, blank=False, null=False)
    data_nascimento = models.DateField(null=False, blank=False)
    email = models.EmailField(null=False, blank=False)


    def __str__(self):
        return self.nome

Note que precisamos criar a variável SEXO_CHOICES e determinar quais as opções que um sexo poderá exercer. Depois disso, criamos o campo sexo em nosso model e determinamos que as opções disponíveis para este campo estão definidas na variável SEXO_CHOICES. Com isso, sempre que o formulário para cadastro (ou edição) de um cliente for submetido, o Django irá verificar se uma das opções foi selecionada. Caso positivo, libera a requisição, caso negativo, alerta ao usuário que apenas estas opções são permitidas a serem selecionadas.

Um outro ponto positivo para o uso do choices é que só precisamos armazenar a chave que irá identificar cada sexo, assim, economizamos um certo espaço no banco de dados, já que só será necessário armazenar um caractere (F, M ou N), não o nome do sexo (Feminino, Masculino ou Nenhuma das opções).

Personalizando a chave primária no Django ORM

Por padrão, o ORM do Django cria, para cada tabela, um campo chamado id e é ele quem identifica, unicamente, os registros no banco de dados. Porém, muitas vezes, precisamos que este campo possua outro nome (ou até outro tipo)… E é isso que veremos neste artigo.

Alterando nome e tipo da chave primária no Django ORM

Como exemplo para este artigo, vamos utilizar um model simples, com apenas alguns campos, conforme podemos ver abaixo:

class Pessoa(models.Model):
    nome = models.CharField(max_length=40, null=False, blank=False)
    email = models.EmailField(null=False, blank=False)

    def __str__(self):
        return self.nome

Ao realizar a migração, a seguinte estrutura será criada no banco de dados:

Podemos notar que, apesar de não definir nenhum campo com o nome id, o Django o criou automaticamente. Por padrão, este campo é do tipo int(11), não permite dados nulos e é utilizado para armazenar a chave primária da tabela. Porém, caso necessário, podemos alterar a estrutura deste campo facilmente utilizando o Django.

Para isso, a única coisa que precisamos fazer é criar um campo que será utilizado como primary_key no model do nosso projeto, como podemos ver abaixo:

class Pessoa(models.Model):
    id_personalizado = models.CharField(max_length=20, primary_key=True)
    nome = models.CharField(max_length=40, null=False, blank=False)
    email = models.EmailField(null=False, blank=False)

    def __str__(self):
        return self.nome

Sendo assim, podemos notar que a única coisa necessária para alterar a chave primária de uma tabela é determinar o atributo primary_key=True e, com isso, este campo será utilizado como chave primária no banco de dados:

Concluindo

Apesar de possuir diversas configurações padrões, o ORM do Django permite a personalização de várias delas. Neste artigo vimos o quão simples é alterar o nome da chave primária de um determinado model.

Criando um ambiente de desenvolvimento PHP com WSL

O WSL é uma alternativa interessante para quem precisa configurar um ambiente de desenvolvimento em Linux dentro do Windows. Com ele você pode escolher a sua distribuição Linux preferida e configurar seu ambiente exatamente da mesma forma que você configuraria em uma máquina Linux ou em um servidor, por exemplo.

Nesse artigo vamos criar um ambiente de desenvolvimento PHP completo, com MySQL e Nginx dentro do WSL.

Instalação do WSL

Antes de mais nada, é preciso habilitar o WSL na sua máquina e instalar a distribuição de sua escolha. Se você ainda não conhece o WSL ou tem dúvidas se sua máquina tem suporte a ele, recomendo a leitura do artigo O que é Windows Subsystem for Linux (WSL)? para saber mais e acompanhar o processo de instalação.

Para esse tutorial vou utilizar o Ubuntu 18.04. Os comandos apresentados aqui podem não funcionar com outras distribuições, mas você pode utilizar esse artigo para ter uma ideia geral.

Instalando o Nginx

Para iniciar vamos iniciar nosso terminal com o WSL e instalar o Nginx. Ele está disponível via apt-get e pode ser instalado com os comandos abaixo como sudo:

sudo apt-get update
sudo apt-get install nginx

Aproveite esse momento e instale utilitários como o git para versionamento de código e um editor de textos de sua preferência, como o vim:

sudo apt-get install git vim

Depois é necessário habilitar o serviço do Nginx dentro do WSL, antes disso verifique se a porta 80 da sua máquina está liberada. Você pode executar o seguinte comando PowerShell como administrador para descobrir isso:

Get-Process -Id (Get-NetTCPConnection -LocalPort 80).OwningProcess

Se o comando retornar erro, a porta 80 está liberada para uso:

Verificando a porta 80 com PowerShell

Feito isso, volte para seu terminal do WSL e execute o comando:

sudo service nginx start

Com isso seu localhost já estará funcionando:

Página inicial do nginx

Como o WSL não suporta o gerenciamento de serviços usando systemd, sempre que você reiniciar a máquina e iniciar uma nova sessão com o WSL, você precisa iniciar o serviço do Nginx novamente. Veremos como resolver isso logo mais.

Instalando o MySQL

O MySQL 5.7 pode ser instalado a partir do apt-get no Ubuntu 18.04:

sudo apt-get install mysql-server

Como também aconteceu com o Nginx, é preciso iniciar o serviço do MySQL manualmente:

sudo service mysql start

Para acessar sua instância do MySQL, é preciso criar um novo usuário no seu banco de dados para ser utilizado junto com sua aplicação. No seu terminal inicie o cliente do MySQL executando sudo mysql e execute a seguinte query:

GRANT ALL ON *.* TO 'admin'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;

Isso irá criar um usuário chamado admin com a senha password. Esse usuário será acessível apenas pelo endereço localhost. Troque o usuário e senha para algo mais seguro e digite exit para sair do cliente do MySQL.

Teste a conexão com o MySQL utilizando algum cliente, você pode utilizar o MySQL Workbench por exemplo:

Teste da conexão com o MySQL

Instalando o PHP

Agora vamos de fato instalar o PHP e configurá-lo para funcionar com o Nginx. É preciso instalar o PHP-FPM (FastCGI Process Manager) para que o Nginx consiga delegar as requisições recebidas para as páginas a serem interpretadas com PHP. Como estamos utilizando o MySQL como banco de dados, é interessante instalar a extensão do MySQL também:

sudo apt-get install php-fpm php-mysql

Com isso será instalado a versão 7.2 do PHP juntamente com o FPM e as extensões do MySQL:

Versão do php

Depois de instalado, inicie o serviço do PHP-FPM:

sudo service php7.2-fpm start

Configurando nosso site

Por fim, vamos configurar nosso site para ser executado com PHP. Crie um arquivo em /etc/nginx/sites-available/localhost com o seguinte conteúdo:

server {
  listen 80;
  root /var/www/html;
  index index.php index.html index.htm index.nginx-debian.html;
  server_name localhost;

  location / {
    try_files $uri $uri/ =404;
  }

  location ~ \.php$ {
    include snippets/fastcgi-php.conf;
    fastcgi_pass unix:/var/run/php/php7.2-fpm.sock;
  }

  location ~ /\.ht {
    deny all;
  }
}

Habilite o site criado para utilizar a nova configuração através de um link simbólico (conhecido também como symlink) no diretório /etc/nginx/sites-enabled e remova a configuração de site padrão com os seguintes comandos:

sudo ln -s /etc/nginx/sites-available/localhost /etc/nginx/sites-enabled/
sudo unlink /etc/nginx/sites-enabled/default

Reinicie o serviço do Nginx para ler essas novas configurações:

sudo service nginx restart

E crie o arquivo /var/www/html/index.php com o seguinte conteúdo:

<?php 
phpinfo();

No meu caso, eu precisei alterar o dono do diretório /var/www/html para poder criar esse arquivo:

sudo chown -R $USER: /var/www/html

Com isso, você deve conseguir ver a configuração do PHP no seu navegador:

Configurações do php

Configurando os serviços para iniciarem automaticamente

Devido a algumas limitações na arquitetura do WSL, não é possível iniciar serviços automaticamente pelo systemd. Para contornar isso podemos iniciar esses serviços a partir do nosso arquivo .bashrc e desabilitar a necessidade de perguntar a senha do sudo para esses serviços.

Lembrando que essa prática não é recomendada em ambientes de produção. Em produção utilize o systemd e nunca permita que serviços que precisam de permissões elevadas rodem sem precisar inserir uma senha.

Adicione as seguintes linhas no seu arquivo /etc/sudoers:

%sudo ALL=NOPASSWD: /etc/init.d/mysql
%sudo ALL=NOPASSWD: /etc/init.d/nginx
%sudo ALL=NOPASSWD: /etc/init.d/php7.2-fpm

E no seu arquivo do ~/.bashrc inclua o seguinte:

sudo /etc/init.d/nginx start
sudo /etc/init.d/mysql start
sudo /etc/init.d/php7.2-fpm start

Com isso, sempre que iniciar seu terminal do WSL os serviços serão iniciados automaticamente. Caso esteja utilizando alguma linguagem diferente, a ideia é a mesma: inclua os serviços necessário no .bashrc e desabilite a senha para esses serviços no /etc/sudoers.

Configurando sua IDE

Após tudo configurado, chegou a hora de configurarmos nossa IDE para utilizar o WSL. Da forma que configuramos nosso ambiente, os scripts PHP estão dentro da estrutura de arquivos do WSL.

Como o WSL não suporta ferramentas com interface gráfica, não podemos instalar nossa IDE.

Podemos resolver isso de algumas formas. Uma delas é salvar nossos arquivos nos diretórios do Windows e dentro do WSL configurar o Nginx para apontar para um diretório dentro de /mnt/c/. Esse diretório é mapeado diretamente com o C: do seu sistema e permite o WSL ter acesso a esses arquivos.

Caso você utilize o VS Code, uma melhor alternativa é utilizar os arquivos salvos diretamente dentro da estrutura do WSL. Existe uma extensão ainda em preview chamada Remote Development. Com ela é possível se conectar com sistemas externos através de SSH, Container ou WSL para trabalhar diretamente com o sistema de arquivos dessas soluções.

Para utilizar o Remote Development com o WSL, instale a extensão Remote – WSL no seu VS code e reinicie o mesmo.

Extensão Remote - WSL

Ao reiniciar, repare no canto esquerdo um novo ícone verde. A partir dele é possível abrir uma nova janela do VS Code com acesso ao sistema de arquivos da sua distribuição no WSL:

Nova janela com acesso ao WSL

Ao abrir essa nova janela, será instalado um agente dentro do WSL que permite a conexão com o VS Code. O ícone verde indicará o nome da sua distribuição que o VS Code está conectado. Ao abrir um diretório você navegará no sistema de arquivos do WSL.

Abra o diretório /var/www/html e podemos observar que nosso index.php está acessível:

Abrir diretório

Arquivos no WSL

Esse agente que é instalado no WSL permite uma melhor integração com o VS Code. Com ele é possível dentro do terminal do WSL abrir qualquer diretório que você esteja navegando utilizando o comando code . e também é possível instalar extensões do VS Code para executarem diretamente dentro do WSL, como por exemplo as extensões de intellisense e debug para PHP:

Extensões instalados no WSL

Para a extensão intellisense do PHP funcionar, é preciso que o executável do PHP esteja disponível no sistema. Instalando essa extensão dentro do WSL você consegue utilizar do executável já disponível no WSL, concentrando todas as funcionalidades necessárias para o seu ambiente em um único lugar.

Conclusão

Aprendemos nesse artigo como criar do zero um ambiente de desenvolvimento para PHP dentro do WSL. Esse ambiente pode ser uma alternativa para quem precisa executar um projeto em ambiente Linux dentro do Windows. Vimos também como configurar o VS Code para acessar diretamente os arquivos dentro do sistema de arquivos do WSL, tornando uma experiência muito próxima com a que teríamos com o Linux.

Criando APIs com o Strapi.io

O uso de APIs vem em constante crescimento nos últimos anos, e isso se deve a grande quantidade de aplicações clientes que precisam consumir dados de um mesmo banco de dados. Essas aplicações clientes vão desde aplicativos desktop até aplicações mobile, fazendo com que mais e mais serviços sejam criados diariamente.

Devido a esse cresimento, cada dia mais tecnologias surgem para auxiliar os desenvolvedores a criar estas APIs. Uma destas tecnologias é o Strapi.io e é sobre ela que vamos falar neste artigo.

O que é o Strapi.io?

O Strap.io é uma ferramenta que visa facilitar a criação de serviços REST através de um painel administrativo totalmente funcional. Desenvolvido em node.js, o Strap.io é open-source e bem simples de se utilizar. Toda a sua documentação pode ser encontrada em sua página principal.

Instalando o Strapi.io

Para instalar o Strapi.io, precisamos apenas do node em nosso computador. Para isso, podemos baixar seu instalador na página oficial da ferramenta. O processo de instalação é bem simples e intuitivo, o famoso “next, next, finish”.

Após instalar o node, estamos aptos a instalar o strapi.io. Para isso, no Terminal (ou CMD, se você usa o Windows), digitamos o seguinte comando: npm install strapi@alpha -g. O comando vai baixar e instalar o strapi em seu SO e o retorno deve ser o seguinte:

Criando o projeto

Após instalar o Strapi.io, chegou a hora de criar nosso projeto. Para isso, abrimos o terminal e digitamos o seguinte comando: strapi new my-project. Este comando irá criar um projeto novo do strapi com o nome “my-project”.

Durante o processo de criação do projeto, precisamos selecionar qual banco de dados vamos utilizar (MySQL, Postgree ou MongoDB), o nome do BD, o Host, Porta de acesso para o BD, nome de usuário e senha do banco de dados selecionado, como mostra a imagem abaixo:

Feito isso, navegamos até seu diretório e executamos seu servidor com os comandos abaixo:

cd my-project
strapi start

Feito isso, seremos redirecionados para a página de registro de usuários do strapi, uma área administrativa com a seguinte URL: http://localhost:1337/admin/plugins/users-permissions/auth/register. Nela inserimos os dados de cadastro e clicamos no botão “Pronto para começar”, conforme visto na imagem abaixo:

Criando nossa API

Após configurar o usuário de acesso à área Administrativa, somos redirecionados para o dashboard do Strapi, onde temos acesso a todos os seus recursos. Agora, o primeiro passo é criar as tabelas do banco de dados que irão armazenar os dados da nossa aplicação. Para isso, clicamos no link “Construtor de conteúdo”. É lá que criamos as tabelas que vamos utilizar em nosso serviço REST:

Na próxima tela, selecionamos a opção “Adicionar Tipo de Conteúdo” e determinamos as configurações da tabela a ser criada:

Feito isso, clicamos no botão “Adicionar Novo Campo” e determinamos os campos que nossa tabela irá possuir, assim como seu tipo. O Strapi provê diversos tipos de campos, conforme visto abaixo:

Ao selecionar o tipo do campo, determinamos o nome do campo e clicamos em “continuar”. Vale lembrar que cada campo tem suas configurações particulares, então a tela abaixo pode variar conforme o tipo de dados que você está criando:

Após determinar todos os campos da tabela, clicamos no botão “Salvar” e a tabela será criada no banco de dados que configuramos anteriormente.

Com isso, estamos quase prontos para consumir nossa API. O último passo é configurar o nível de acesso e quem é permitido a consumir os recursos da API. Para isso, vamos até o menu “Papeis e Permissões” e selecionamos a permissão “Public”.

Observação: Esta permissão é responsável por configurar o acesso público da nossa API, ou seja, qualquer um que possuir a rota da nossa API, poderá consumir nosso serviço REST, então é muito importante que você reveja a necessidade do seu projeto antes de liberar a sua API para o público. Como estamos em um ambiente de desenvolvimento, não vamos nos atentar a isso.

Agora, na sessão “Permissões”, determinamos os métodos que os usuários que possuírem a permissão pública poderão efetuar em nossa tabela de clientes:

Vamos deixar todas as opções como ativas. E é isso, finalmente temos nosso serviço de manipulação de clientes ativo e funcionando, chegou a hora de testar!

Testando nosso serviço

Agora podemos testar nossa API de clientes. Para isso, é só fazer uma requisição para a rota http://localhost:1337/clientes. Neste teste, vou utilizar o Postman, uma ferramenta para envio de requisições HTTP.

Sendo assim, enviando uma requisição POST para a rota mencionada acima e passando a idade e o nome no corpo da requisição, temos um novo cliente cadastrado, como podemos ver nas imagens abaixo:

Podemos também fazer todos os outros métodos básicos de um CRUD, como editar e remover um cliente do nosso banco de dados utilizando, respectivamente, os métodos PUT e DELETE:

Concluindo

Então é isso. Neste artigo vimos uma ótima ferramenta para criação de APIs de forma fácil, rápida e intuitiva. Vale ressaltar que esta ferramenta possui todos os métodos para controle de acesso e permissão e que tudo isso pode ser visto na sua documentação oficial

Protegendo suas aplicações Python de SQL Injection

Um dos maiores problemas que assombram os desenvolvedores de software é o SQL Injection. Essa técnica pode permitir que um código SQL seja executado através da aplicação cliente sem qualquer tipo de restrição e, assim, alterar os dados sem qualquer conhecimento dos administradores do sistema. Parece grave, certo? E, realmente, é. Sendo assim, neste artigo falaremos um pouco sobre o SQL Injection e como proteger aplicações Python deste tipo de ataque.

O problema

Como dito anteriormente, o SQL Injection permite que código SQL seja executado através da aplicação cliente diretamente no banco de dados. Isso permite que hackers consigam alterar dados de forma irrestrita e sem consentimento dos administradores do sistema, o que é um problema muito grave em relação a segurança de um sistema. Para entender melhor este problema, vamos a um exemplo prático.

Imagine uma aplicação simples em que seja possível atualizar clientes passando seu nome e idade. Focando apenas no back-end da aplicação e sem qualquer tipo de verificação de SQL Injection, o código responsável por atualizar clientes seria basicamente da seguinte forma:

nome = 'João'
cursor.execute(f"UPDATE cliente SET nome={nome} WHERE idcliente=13")

O código acima irá atualizar o nome do cliente com id 13 para “João”. Até aí, tudo bem. Estamos apenas atualizando o nome de um cliente em nosso banco de dados. Porém, imagine que, ao invés de passar apenas ‘João’ para a variável nome, passarmos um código SQL:

nome = "'Carlos' , idade = 80"
cursor.execute(f"UPDATE cliente SET nome={nome} WHERE idcliente=13")

O código acima permitirá que o nome e idade do cliente com id 13 sejam alterados simultaneamente, sem permissão ou consentimento do administrador do sistema. Até pode paracer bobagem não permitir a edição da idade de um cliente, porém, imagine um sistema bancário com este mesmo problema e que permita que o valor do saldo seja alterado pelo usuário… Complicou, né?

A solução

Para solucionar o problema do SQL Injection, precisamos parametrizar as querys utilizadas em nosso programa e, assim, não permitir que um código SQL seja executado pelo lado cliente da aplicação. Para isso, alteramos a query da seguinte forma:

nome = "'Carlos' , idade = 80"
cursor.execute("UPDATE cliente SET nome=%(nome)s WHERE idcliente=13", ({'nome': nome, }))

Com o código acima, não vamos mais executar o código presente na variável "nome" no UPDATE. Ao invés disso, todo o conteúdo desta variável será armazenado como nome do cliente com id 13. Fazendo com que, o nome do cliente com id 13 seja "Carlos, idade = 80" e a sua idade permaneça inalterada.

Concluindo

Desta forma, não vamos mais permitir que os campos de uma determinada tabela sejam alterados sem permissão do sistema e, assim, garantimos muito mais segurança para a nossa aplicação.

Como se tornar um DBA?

Você da área de TI que se interessa em banco de dados, provavelmente almeja um dia ser um DBA. Com tantos dados que são gerados a cada segundo, a profissão de administrador de banco de dados (DBA) torna-se necessária. Uma vez que ele faz com que os dados sejam armazenados de forma segura, resolve possíveis problemas, enfim, realiza muitas outras funções importantes.

E você, tem interesse na profissão? Será que você tem o perfil de um DBA?

O que é e como se tornar um DBA?

DBA vem de Database Administrator, ou seja, um administrador de banco de dados. Este profissional é responsável por manter o banco de dados seguro, além de gerenciar, monitorar, efetuar backups, aprimorar a performance, dentre outras tarefas.

É uma profissão de alta responsabilidade, pois lida com dados que são importantes para a empresa e deve estar sempre preparado para investigar problemas quando houver e dar suas soluções.

Muitas pessoas não gostam de trabalhar sob pressão, mas essa é uma profissão que exige isso. Se algo acontecer, como por exemplo perda de um dado importante, o DBA deverá recuperá-lo o mais rápido possível e, é claro, sem falhas.

Muitos dos profissionais de DBA vem de graduações como Engenharia da Computação, Sistemas de Informação, Processamento de dados ou até mesmo de cursos específicos de banco de dados. Na imagem abaixo do Guia de Profissões do site de vagas Catho podemos ver alguns desses dados:

Dados sobre a carreira de DBA

Você pode estudar vários bancos de dados e se especializar em um ou outro, afinal, não dá para saber 100% de todas as opções que temos. Por exemplo, se você tem mais afinidade com o SQL Server, pode se especializar nele, mas deve saber pelo menos um pouco de cada um dos outros. Na imagem acima também podemos ver o quanto o inglês é importante, não só na carreira de um DBA mas em toda área de TI.

Mas, não é só de SGBD em sí que um DBA vive, é importantíssimo que esse profissional saiba modelagem de dados, pensar em todo o banco antes mesmo de criá-lo, como o relacionamento entre tabelas por exemplo, pois esse é o primeiro passo para que não venha a ter problemas futuros no banco.

Este é um profissional que deve estudar muito (assim como toda área de TI), para que assim tenha muito conhecimento para resolver os problemas de imediato. Também deve ser uma pessoa organizada e claro, gostar de tecnologia. Deve sempre se atualizar e buscar a evolução do seu trabalho, pois tem uma grande importância para a empresa.

Essa é uma profissão que só tende a crescer, pois cada vez mais as empresas irão precisar aperfeiçoar, otimizar e escalar seus bancos de dados. Sabemos que a perda de dados ou qualquer outro erro no banco, podem trazem graves consequências para a empresa, podendo até mesmo vir a falência.

Aqui no TreinaWeb temos cursos dos principais bancos de dados do mercado.

Entity Framework Core com MySQL

Este artigo será bem prático, mostrando como se conectar a uma base MySQL no Entity Framework Core.

Um pouco de história

Entity Framework Core é uma versão leve, extensível e multiplataforma do Entity Framework.

Criado com base no .NET Core, o Entity Core procurou manter a mesma experiência que o desenvolvedor possuia com o Entity Framework 6.X, mantendo a maioria das APIs de alto nível. Ao mesmo tempo, fazendo uso de um conjunto completamente novo de componentes.

Isso significa que mesmo mantendo parte da estrutura familiar do Entity 6.X, o Entity Core não herdou automaticamente os recursos deste framework. Uma prova disso é que quando ele foi lançado no ano passado, o framework suportava apenas os bancos de dados abaixo:

  • SQL Server;
  • SQLite;
  • Postgres;
  • SQL Server Compact;
  • E os bancos suportados pela biblioteca da DevArt (que é paga).

Mas, com um core totalmente reformulado, o Entity Core se tornou mais leve e extensível que a antiga versão da biblioteca, permitindo que novos recursos fossem adicionados com facilidade.

Agora na sua 2ª versão, o Entity Core já suporta mais bancos de dados e neste artigo veremos como utilizá-lo com uma base de dados MySQL.

Ambiente

Para este artigo, estou utilizando o ambiente abaixo:

  • NET Core SDK 2.0
  • Visual Studio Core
  • MySQL Server 5.7
  • Mac OS High Sierra

Criando o projeto

Por estar no Mac, vou criar uma aplicação console pelo terminal:

dotnet new console -o efcoremysql

E nela vou adicionar as bibliotecas abaixo:

dotnet add package Microsoft.EntityFrameworkCore.Design
dotnet add package Pomelo.EntityFrameworkCore.MySql

E para adicionar os comandos do Entity Core no terminal, é necessário adicionar no arquivo de configuração do projeto (efcoremysql.csproj) a linha abaixo:

<ItemGroup>
    <DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="2.0.0" />
 </ItemGroup>

Com isso, pode ser aplicado o restore:

dotnet restore

Configurando o acesso ao banco de dados

Por ter configurado os comandos do Entity Core para a aplicação, é possível utilizar o comando ef dbcontext scaffold para já criar um context configurado:

dotnet ef dbcontext scaffold "Server=localhost;User Id=root;Password=1234;Database=treinaweb" "Pomelo.EntityFrameworkCore.MySql" -c MyDbContext

Que possuirá o código abaixo:

public partial class MyDbContext : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        if (!optionsBuilder.IsConfigured)
        {
            optionsBuilder.UseMySql("Server=localhost;User Id=root;Password=1234;Database=treinaweb");
        }
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {}
}

Configurando o acesso ao banco de dados

Com o acesso ao banco configurado, podemos definir as entidades:

public class Album
{
    public int Id { get; set; }
    public string Nome { get; set; }
    public int Ano { get; set; }
    public string Observacoes { get; set; }
    public string Email { get; set; }

    public virtual List<Musica> Musicas { get; set; }
}


public class Musica
{
    public long Id { get; set; }
    public string Nome { get; set; }

    public virtual Album Album { get; set; }
}

E definí-las no Context:

public partial class MyDbContext : DbContext
{
    public DbSet<Album> Albuns { get; set; }

    public DbSet<Musica> Musicas { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        if (!optionsBuilder.IsConfigured)
        {
            optionsBuilder.UseMySql("Server=localhost;User Id=root;Password=1234;Database=treinaweb");
        }
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {}
}

E com isso criar uma migration:

dotnet ef migrations add InitialMigration

Execute o comando abaixo para criar a base de dados:

dotnet ef database update

Manipulando dados do banco de dados

Agora que o acesso foi configurado e a nossa base criada, podemos inserir alguns dados no banco:

private static void InsertData()
{
    using(var context = new MyDbContext())
    {

        var album = new Album()
        {
            Nome = "Acústico MTV - Legião Urbana",
            Ano = 1999,
            Email = "contato@legiaourbana.com.br"
        };

        context.Albuns.Add(album);

        context.Musicas.Add(new Musica
        {
            Nome = "Índios",
            Album = album
        });
        context.Musicas.Add(new Musica
        {
            Nome = "Pais e Filhos",
            Album = album
        });

        context.Musicas.Add(new Musica
        {
            Nome = "Eu sei",
            Album = album
        });

        context.SaveChanges();
    }
}

E visualizá-los:

private static void PrintData()
{
    using (var context = new MyDbContext())
    {
        var musicas = context.Musicas.Include(m => m.Album);
        foreach(var musica in musicas)
        {
            var data = new StringBuilder();
            data.AppendLine($"Musica: {musica.Nome}");
            data.AppendLine($"Album: {musica.Album.Nome}");
            Console.WriteLine(data.ToString());
        }
    }
}

Conclusão

Quando o Entity Framework Core foi criado, era complicado utilizá-lo com o MySQL. Na época a única alternativa disponível eram os provedores da DevArt, que são pagos.

Felizmente, conforme a biblioteca foi sendo atualizada, novos provedores foram sendo adicionados, e hoje é possível utilizar o provedor da Pomelo para se conectar ao MySQL.

Mesmo não sendo o provedor oficial (que na criação deste artigo ainda está em beta e apresenta alguns erros), o provedor da Pomelo é muito poderoso e pode ser utilizado em um ambiente de produção sem maiores preocupações.

JUNTE-SE A MAIS DE 150.000 PROGRAMADORES