Configurar uma VLAN

Afinal o que é uma VLAN?

Devido ao crescimento e complexidade das redes informáticas, é muito comum nos dias de hoje que a rede física seja “dividida” em vários segmentos lógicos, denominadas de VLANs. Uma VLAN é basicamente uma rede lógica onde podemos agrupar várias máquinas de acordo com vários critérios (ex. grupos de utilizadores, por departamentos, tipo de tráfego, etc).

As VLANs permitem a segmentação das redes físicas, sendo que a comunicação entre máquinas de VLANs diferentes terá de passar obrigatoriamente por um router ou outro equipamento capaz de realizar encaminhamento (routing), que será responsável por encaminhar o tráfego entre redes (VLANs) distintas. De referir ainda que uma VLAN define um domínio de broadcast (ou seja, um broadcast apenas chega aos equipamentos de uma mesma VLAN). As VLANs oferecem ainda outras vantagens das quais se destacam: segurança, escalabilidade, flexibilidade, redução de custos, etc.

No exemplo da imagem a seguir temos 2 VLANs criadas no switch (VLAN 100 e VLAN 200).  Na VLAN 100 temos o Host A e o Host B. Na VLAN 200 temos o Host C e o Host D. Num switch podemos configurar várias VLANs criando assim vários domínios de broadcast  – o tráfego de uma VLAN não é enviado para outra VLAN. Para que tal aconteça é necessário que haja encaminhamento (por exemplo através de um router). Assim, neste exemplo, independentemente das máquinas estarem ligadas ao mesmo equipamento físico, o Host A só consegue comunicar com o Host B (e vice-versa) e o mesmo acontece com o Host C e o Host D.

Quando ter uma rede física segmentada em VLANs?

Imaginem, por exemplo, que foram contactados para implementar uma rede numa Universidade. Considerando que vamos ter utilizadores/serviços/perfis distintos (ex. Apoio à Direção, pessoal da contabilidade, pessoal dos recursos humanos, externos, etc) a ligarem-se à mesma rede física. Nesse sentido é importante que as máquinas estejam em redes separadas (mesmo estando ligadas no mesmo switch ou segmento de rede). Não faz sentido (essencialmente por questões de segurança), que um utilizador (ex.um aluno), se ligue à mesma rede onde estão os utilizadores que fazem parte do serviço da contabilidade.

Vejam o seguinte cenário para um edifício: 3 grupos distintos de utilizadores que pertencem à contabilidadegestão de recursos humanos e apoio à direção. Os utilizadores dos três serviços encontram-se distribuídos pelos vários pisos no mesmo edifício, mas em termos de rede (uma vez que foram configuradas VLANs), encontram-se na rede (VLAN) definida para cada serviço.

A comunicação entre utilizadores de serviços diferentes só é possível, se configurado o encaminhamento no router.

A constituição de VLANs numa rede física, pode dever-se a questões de:

  • Organização – diferentes departamentos/serviços podem ter a sua própria VLAN. De referir que a mesma VLAN pode ser configurada ao longo de vários switchs, permitindo assim que utilizadores do mesmo departamento/serviço estejam em locais físicos distintos (ex. Utilizador A – Polo 1, utilizador B – Polo 2) da mesma instituição;
  • Segurança– Pelas questões que já foram referidas acima, ou por exemplo para que os utilizadores de uma rede não tenham acesso a determinados servidores;
  • Segmentação– Permite dividir a rede física, em redes lógicas mais pequenas e assim tem um melhor controlo/gestão a nível de utilização/tráfego.

 

VLANs – Tipo de portas

Um switch com a capacidade para criação de VLAN suporta dois tipos de portas:

  • Portas de Acesso (ligações de acesso)
  • Portas Trunk (ligações partilhadas)

Uma Porta de Acesso (access), permite associar uma porta do switch a uma vlan. As portas do tipo acesso são usadas para ligar PCs, impressoras, etc. Por omissão, todas as portas do switch vêm configuradas na VLAN 1.

Uma Porta Trunk, normalmente usada para interligação de switchs ou ligação a routers, e permite a passagem de tráfego de várias VLANs. Configurando uma porta como trunk, todo o tráfego de todas as VLANs criadas no switch podem passar por lá, no entanto o administrador pode limitar ao número de VLANs que pretender. Como podem ver pela imagem seguinte, a ligação entre o switch A e o Switch B é realizado através de portas Trunk isto porque, no mesmo link, é necessário passar tráfego da VLAN 100 e 200.

Como configurar?

Para este artigo vamos considerar o exemplo anterior. Vamos também definir o seguinte endereçamento:

  • VLAN 100: 192.168.100.0/24
  • VLAN 200: 192.168.200.0/24

Para começar vamos criar as VLANs no switch A e depois associar a porta Fa0/2 e Fa0/3 à VLAN 100 e a Fa0/4 à VLAN 200. Vamos ainda atribuir o nome Estudantes à VLAN 100 e Docentes à VLAN 200. Para tal, entramos no SwitchA e realizamos as seguintes configurações:

SwitchA> enable
SwitchA# configure terminal
SwitchA(config)#vlan 100
SwitchA(config-vlan)#name estudantes
SwitchA(config-vlan)#vlan 200
SwitchA(config-vlan)#name docentes
SwitchA(config-vlan)#exit
 
SwitchA(config)#interface fastEthernet 0/2
SwitchA(config-if)#switchport mode access
SwitchA(config-if)#switchport access vlan 100
 
SwitchA(config-if)#interface fastEthernet 0/3
SwitchA(config-if)#switchport mode access
SwitchA(config-if)#switchport access vlan 100
 
SwitchA(config-if)#interface fastEthernet 0/4
SwitchA(config-if)#switchport mode access
SwitchA(config-if)#switchport access vlan 200

Devem realizar uma configuração semelhante para o SwitchB

SwitchB> enable
SwitchB# configure terminal
SwitchB(config)#vlan 100
SwitchB(config-vlan)#name estudantes
SwitchB(config-vlan)#vlan 200
SwitchB(config-vlan)#name docentes
SwitchB(config-vlan)#exit
 
SwitchB(config)#interface fastEthernet 0/2
SwitchB(config-if)#switchport mode access
SwitchB(config-if)#switchport access vlan 100
 
SwitchB(config-if)#interface fastEthernet 0/3
SwitchB(config-if)#switchport mode access
SwitchB(config-if)#switchport access vlan 200
 
SwitchB(config-if)#interface fastEthernet 0/4
SwitchB(config-if)#switchport mode access
SwitchB(config-if)#switchport access vlan 200

Por fim vamos configurar as portas trunk. Para tal vamos ao SwitchA, e definimos a porta fastEthernet 0/1 como Trunk.

SwitchA(config-if)#interface fastEthernet 0/1
SwitchA(config-if)#switchport mode trunk

Devem realizar uma configuração semelhante para o SwitchB

SwitchB(config-if)#interface fastEthernet 0/1
SwitchB(config-if)#switchport mode trunk

Caso pretendam ver as VLANS por porta, podem executar o comando show vlan

Testes

Vamos agora verificar se há comunicação entre máquinas da mesma VLAN, ligadas a switchs diferentes. Para a realização de testes vamos tentar pingar do PC0 para o PC3 (que pertencem à VLAN 100). Em seguida vamos pingar do PC2 para para PC5 (que pertencem à VLAN 200).

Comunicação entre PC0 e PC3

Comunicação entre PC2 e PC5

Espero que tenham percebido o conceito de VLAN, e caso queiram colocar em prática podem sempre consultar a data sheet dos vossos switchs para saber se suportam VLANS.

Existem ainda outros conceitos dentro do assunto das VLANs como por exemplo VTP, trunking (protocolo 802.1Q ou ISL da Cisco), subinterfaces, etc.

Dica: Como aceder ao histórico da Área de Transferência do Windows 10

O Windows 10 tem mudado muito o que a Microsoft oferece. Para além do que mudou em relação à versão anterior, também as novidades têm sido muitas e adaptadas aos utilizadores.

Uma delas, que era pedida há muitos anos, chegou finalmente para ajudar quem usa o sistema operativo. Falamos da Área de Transferência e de tudo o que ali tem mudado. Há já um histórico, que deve saber usar.

Uma excelente opção presente no Windows 10

A Área de Transferência não é uma novidade no Windows 10. Há muito que podemos guardar texto, imagens ou qualquer ficheiro para usar noutras apps ou áreas deste sistema. É uma ajuda preciosa no dia a dia dos utilizadores.

Claro que a Microsoft quis dar ao Windows 10 uma melhoria nesta área e agora existe um histórico do que ali se coloca. Antes de o poder usar, o utilizador necessita de garantir que está ativado.

Windows 10 Área Transferência texto ficheiro

Ligar o histórico do sistema da Microsoft

Para confirmar este passo deve aceder às Definições e depois a Sistema. Aí dentro escolham o separador Área de Transferência e garantam que o Histórico de está ativo. Se necessitarem, no final, podem limpar os dados que estiverem recolhidos.

Agora que sabem que está ativo o histórico, podem começar a recolher elementos. Para lhe acederem, podem seguir o mesmo princípio que usaram até agora no Windows 10. Em vez de usarem o Ctrl + V, devem usar o Win + V.

Windows 10 Área Transferência texto ficheiro

Aceder à área de Transferência e ao que está copiado

Onde quer que seja utilizada esta sequência de teclas, vai surgir uma nova janela com o estiveram a recolher. Pode ser texto, uma imagem ou outro elemento, e vão conseguir ver o que está em cada um com facilidade. Para usarem só precisam de carregar e será colado na app.

Se quiserem eliminar qualquer entrada, só precisam de a chamar e carregar na zona do seu menu. Aí dentro encontram as opções presentes e que podem ser usadas. Falamos da possibilidade de Eliminar ou de Afixar.

Windows 10 Área Transferência texto ficheiro

Texto, ficheiro ou outros elementos ali presentes

Nesse mesmo menu, podem simplesmente limpar todo o conteúdo que ali tiverem. Basta escolher a opção Desmarcar tudo e todos os elementos vão ser simplesmente apagados. Claro que não voltam a poder ser usados.

Esta é mais uma excelente opção que a Microsoft deu ao Windows 10. Depois de anos a ser pedida, finalmente está disponível e pronta a ser usada. Explorem e vejam o que podem fazer com esta excelente funcionalidade.

Informação detalhada sobre o disco do Windows 10

Gerir o Windows 10 é normalmente simples e fácil de fazer por qualquer utilizador. As ferramentas necessárias estão presentes e prontas a ser usadas a qualquer momento e em qualquer situação.

Há, no entanto, informação importante que apenas surge com comandos específicos. Estes são importantes e podem também ser usados para obter dados nem sempre visíveis. Um exemplo é a informação detalhada do disco do Windows 10. Veja como a obter.

Saber muito mais sobre o Windows 10

Para muitos utilizadores, toda a informação que podem obter sobre o seu computador é essencial. Esta surge de várias fontes, com tudo estar a centrar-se no Windows 10 e no hardware que está presente.

Para além da informação que o Windows 10 apresenta sobre o disco ou SSD, há outra que pode ser obtida. Está escondida, mas com um simples comando pode ser tornada pública. Assim, e numa simples janela de DOS ou PowerShell, podem obter muitos dados.

A informação vem de um simples comando

Executem então o comando seguinte numa dessas janelas e vão poder obter dados sobre o disco ou pen USB presente e ligada ao Windows 10:

wmic diskdrive get model,serialNumber,size,mediaType

Podem ver de imediato a informação solicitada no comando. Esta está arrumada por colunas de dados e linhas de dispositivos. Estes contemplam discos, SSDs ou pens USB. Basta controlar o que é apresentado, que o mapeamento é direto.

Windows 10 disco USB comando informação

Também os dados de uma Pen USB são mostrados

Mas este comando pode ser alterado e adaptado. Para além da chamada wmic diskdrive get, podem definir os elementos, procurando-os aqui:

wmic diskdrive get model,index,firmwareRevision,status,interfaceType,totalHeads,totalTracks,totalCylinders,totalSectors,partitions

Conforme este segundo exemplo, apresentado no comando e na imagem acima, podemos facilmente adicionar outros elementos de pesquisa.

Explorem tudo o que o Windows 10 tem para dar ao utilizador e encontram de certeza elementos inegavelmente úteis. Este é um exemplo do tipo de informação que podem obter com um simples comando, direto e prático.

Building a Project Starter with NPM Scripts

When it comes to building a simple front-end project, how do you get started? What are the tools you need? I suspect everyone will have a different answer. Do you start with a (JS or CSS) framework, or off-the-shelf boilerplate? Perhaps you use a task runner (like Gulp to orchestrate your project’s needs. Or do you start simple, with just HTML and a CSS file?

The front-end tooling landscape can be confusing, and at times overwhelming – and when you’re dedicating your time to learning HTML, CSS and Javascript, it feels like yet another thing you need to make time to learn. In this series of articles I want to help developers understand some of the tools and methodologies that have become commonplace for building web projects. Over the next three articles we’ll build a simple project starter (or boilerplate) together. We’ll cover:

  1. An introduction to using NPM scripts (this article) for compiling Sass, running a server and live reloading.
  2. Getting up and running with Parcel, a minimal-config application bundler.
  3. Building out a reusable Sass architecture

Feel free to skip over the parts you’re already familiar with.

Why do we need a project starter repository?

I’ve written previously on this blog about keeping things simple and building dependency-free — and for a basic, minimal site, this approach has a lot to recommend it. But the vast majority of my projects would benefit from a bit more tooling. In any given project, it’s likely that at the very least I’ll want to:

  • Run a local server
  • Compile SCSS to CSS, and minify the output
  • Live reload (show changes in the browser without the need for manual refresh)
  • Optimise images
  • Create SVG icon sprites

In larger projects, there are plenty more tooling options we could add into the mix to help us build performant, accessible websites. We might want module bundling, code splitting and transpiling. On the CSS side, perhaps we’d like to inline our critical CSS, or purge unused selectors.

If you don’t know what some of these words mean, you’re not alone! Front-end development has got a lot more complex in recent years, and it can be hard to keep abreast of the constant changes to best practices. One article that has really helped me understand the vast tooling landscape that these days falls into the realm of front-end development is Modern Javascript Explained For Dinosaurs. Although a couple of years old, this article is still extremely relevant, and explains succinctly how Javascript has evolved to become such a vital part of our workflow.

All this takes time to set up and configure, and to do it from scratch every time we start a new project wouldn’t be ideal. Which is why it’s useful to have a starter repository that we can clone or download, with everything we need to start coding straight away.

Choosing our tools

I’m not a person who loves spending time setting up complex tooling. I want my tools to demand as little time from me as possible, so that I can concentrate on the things I love doing! Whilst I’ve used Gulp in the past, it now seems a less necessary part of the toolchain: virtually all dependencies can be installed via NPM and configuring them with NPM scripts is no more difficult than configuring them with Gulp. So using a task runner seems a bit redundant, and would only add an extra dependency to the project.

The tools I’ve chosen here are a personal preference, and suit the kind of projects I like to build. They’re not necessarily everyone’s choice, and there are plenty of different ways to do things. But I hope this tutorial will help you get a bit more familiar with some of the tools that have become popular among developers, so that you can make your own choices.

With that in mind, let’s begin building our project starter, and learn about the tools we’ll be using along the way. Feel free to skip over any parts you’re already familiar with.

Installing Node.js

The very first thing we need to do to get our project set up to work with NPM scripts is to make sure we have Node.js installed globally. This sounds simple enough, but already things start to get a little more complicated when we realise there are a number of different ways to do this:

NVM is my preferred option, as it allows us to easily upgrade our node version, see which version we’re currently running, list other installed versions or switch to another version using single commands. But it requires additional steps to install depending on your setup, which is beyond the scope of this particular article.

Once you have Node installed (by whichever method suits you), you can check the currently installed version by running node -v. (You might want to upgrade to the latest version.) If you’re using NVM you could (optionally) create a .nvmrc config file to ensure you always run the correct Node version for your project.

NPM

Installing Node also installs NPM (Node Package Manager). This is basically a huge library of open source Javascript development tools (or packages) that anyone can publish to. We have direct access to this library of tools and (for better or worse!) can install any of them in our projects.

NPM or Yarn?

Yarn is an alternative package manager, similar to NPM, and almost as popular. In fact, many people consider it an improvement. It can be used in a similar way, to install dependencies. If you prefer to use Yarn over NPM, you can safely substitute NPM commands with the Yarn equivalent anywhere they’re used in this article.

Initialising the project

First, let’s create a new project folder, which we’ll (imaginitively) call new-project. Open the terminal, and inside that folder run:

npm init

Running this command brings up several steps for initialising our project in the command line, such as adding a name and description. You can hit Enter to skip through each of these if you don’t want to complete them right away – we’ll be able to edit them later on. You’ll then see that a package.json file has been created, which should look something like this:

{
	"name": "project-starter",
	"version": "1.0.0",
	"description": "",
	"main": "index.js",
	"scripts": {
		"test": "echo \"Error: no test specified\" && exit 1"
	},
	"author": "",
	"license": "ISC"
}

This file contains all the information about our project, and is where we can edit the details that we just skipped through.

Any packages that we install from NPM will be automatically listed in the package.json file. It’s also where we’ll configure the scripts that will build and run our project. We’ll install some packages and configure these shortly, but first we’ll need a basic project architecture, and some files to work with.

Project structure

We’ll start with a folder structure that looks like this:

new-project
	index.html
  src
    icons
    images
    js
    scss
  node_modules
  package.json

We’ve already generated the node_modules directory and package.json in the root of the project. We just need to create a directory called src, containing directories for images, JS, SCSS and icons, plus an index.html file.

Creating our folder structure from the command line

You could create the above folder structure manually, either in your text editor of choice or in your computer’s file system. But if you want to save time, you could do it from the terminal instead. In the root of the project, you could run:

touch index.html
mkdir src && cd src
mkdir js scss images icons
cd ../

Line by line, this code:

  1. Creates a new index.html file
  2. Creates a new src directory and moves us into the newly-created directory
  3. Creates directories inside src called jsscssimages and icons, and a file called index.html.
  4. Brings us back up to the project root.

Now let’s add the following to our index.html file so that we can see our site in the browser:

<!DOCTYPE html>
<html lang="en">
	<head>
		<meta charset="UTF-8" />
		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
		<meta http-equiv="X-UA-Compatible" content="ie=edge" />
		<title>Project starter</title>
		<link rel="stylesheet" type="text/css" href="dist/css/styles.css" />
	</head>
	<body>
		<h1>Hello world!</h1>
	</body>
</html>

Installing dependencies

Now that we have our basic folder structure, we can start to install some packages and write some NPM scripts that will let us build and view our website. The scripts we’re going to write will:

  1. Run a local server
  2. Compile Sass to CSS
  3. Watch for changes and reload the page whenever we update our HTML or CSS

Let’s install the node-sass package from NPM, which compiles .scss files to CSS. In the terminal run:

npm install node-sass --save-dev

Once this command has finished running, you should see a couple of new things:

  1. A directory called node_modules has been created
  2. In the package.json file, node-sass is now listed in “devDependencies”.
  3. Adds a package-lock.json file. This isn’t something we should ever need to touch.

Adding a .gitignore

The node_modules directory is where the code for all of our project dependencies will live. The contents of this folder should not be committed to Github (or your favourite repository host), as installing just a few dependencies could result in hundreds of thousands of files! So the next thing we should do is add a .gitignore file in the project root:

touch .gitignore && echo "node_modules" >> .gitignore

This command creates the .gitignore file and adds node_modules to it. (Again, you can do this manually if you prefer.) Now we are safe in the knowledge that our packages will not be committed.

If we’re not committing these files, then how can we share our dependencies with other users? Well, this down to the package.json file. It tells us the name and version number of any dependencies we have installed. Anyone who clones or forks the project (including us, when we use it to start a new project) can simply run npm install and all the associated dependencies will be fetched and downloaded from NPM.

Types of dependencies

When we installed node-sass we ran the install command with the --save-dev flag. This installs the project as a “dev dependency”. Other packages may not require this command, and save a package under “dependencies” instead. The difference is that regular dependencies are runtime dependencies, whereas dev dependencies are buildtime dependencies. node-sass is required to build your project, so it’s a dev dependency. But something like, say, a carousel plugin, or framework that needs to be downloaded on the client side, (like React) would need to be a regular dependency.

Now we’ll also install Browsersync as a dev dependency. Browsersync will run a local server and reload the browser when our files change.

npm install browser-sync --save-dev

Writing NPM scripts

Now it’s time to write some scripts to run our project. We’re going to write these in the “scripts” section of our package.json.

Sass to CSS

NPM scripts consist of a key (the name of the script, which is what we would type in the terminal in order to run it) and a value – the script itself, which will be executed when we run the command. First we’ll write the script which compiles Sass to CSS. We’ll give it the name scss (we could name it anything we like) and add it to our “scripts” section:

"scripts": {
  "scss": "node-sass --output-style compressed -o dist/css src/scss",
}

The node-sass package contains some options, some of which we’re defining here. We’re specifying the output style (“compressed”), the output directory (dist/css) and the source directory (src/scss), which is currently empty. Let’s create a source .scss file from the terminal:

touch src/scss/styles.scss

Add a few styles to the newly-created file, then go back to the terminal and run:

npm run scss

You should then see a new directory called dist has been created, containing your compiled CSS. Now, every time you make changes to your styles.scss file, you can run the script and those changes will be compiled.

Live reloading

Our first script is working great, but it’s not very useful yet, as every time we make changes to our code we need to got back to the terminal and run the script again. What we would be much better it to run a local server and see our changes reflected instantaneously in the browser. In order to do that we’ll write a script that uses Browsersync, which we’ve already installed.

First, let’s write the script that runs the server, which we’ll call serve:

"scripts": {
	"scss": "node-sass --output-style compressed -o dist/css src/scss",
	"serve": "browser-sync start --server --files 'dist/css/*.css, **/*.html'"
}

In the --files option we’re listing the files that Browsersync should monitor. It will reload the page when any of these change. If we run this script now (npm run serve), it will start a local server and we can preview our web page by going to http://localhost:3000 in the browser.

Watching for changes

Currently we still need to run our scss script when we want to compile our Sass. What we need our scripts to do is:

  1. Watch our src/scss directory for changes.
  2. When a change occurs, compile this to CSS in dist/css.
  3. When dist/css is updated, reload the page.

First we need to install an NPM package called onchange, to watch for changes to the source files:

npm install onchange --save-dev

We can write NPM scripts that run other scripts. Let’s add the script that watches for changes and triggers our scss command to run:

"scripts": {
	"scss": "node-sass --output-style compressed -o dist/css src/scss",
	"serve": "browser-sync start --server --files 'dist/css/*.css, **/*.html'",
	"watch:css": "onchange 'src/scss' -- npm run scss",
}

The watch:css script watches for changes using the onchange package (src/scss) and runs our scss script when changes occur.

Combining scripts

Now we need to run two commands in parallel: The serve command to run our server, and the watch:css command to compile our Sass to CSS, which will trigger the page reload. Using NPM scripts we can easily run commands consecutively using the && operator:

"scripts": {
  /*...*/
  "start": "npm run serve && npm run scss"
}

However, this won’t achieve what we want, as the script will wait until after the serve script has finished running before it begins running the scss script. If we go ahead and write this script, then run it in the terminal (npm start), then npm run scss won’t be triggered until we’ve stopped the server.

To enable us to run commands in parallel, we need to install another package. NPM has several options to choose from. The one I’ve picked is npm-run-all:

npm install npm-run-all --save-dev

The main options in this package (or at least, the ones we care about) are run-s and run-p. The former is for running sequentially, the latter is for running commands in parallel. Once we have installed this package, we can use it to write the script that runs both our serve and watch:css commands in parallel. (We’ll call it start.)

"scripts": {
	"scss": "node-sass --output-style compressed -o dist/css src/scss",
	"serve": "browser-sync start --server --files 'dist/css/*.css, **/*.html'",
	"watch:css": "onchange 'src/scss' -- npm run scss",
	"start": "run-p serve watch:css"
}

We now have a very basic starter project. We’ve written some scripts that allow us to simply type the command npm start to run a server, watch for changes, compile Sass to CSS and reload the page. An example repository can be found here.

We could now go ahead and install some packages and write scripts to automate some of our other tasks, such as optimising images, creating SVG sprites and uglifying JS. This CSS Tricks article has a great rundown of a few more scripts you might like to add, as well as a starter repository. (Be aware, one or two of the packages included in the example have since been deprecated. You may need to search NPM for substitutes.)

This may serve us perfectly well for small projects, but the more tasks we want to run, the more scripts we’ll need to write, and orchestrating them all becomes more complex. So, in the next article we’ll look at how Parcel, an application bundler, can automate a lot of these tasks for us with minimal configuration, and provide the tooling we need in order to build larger projects.

 

Dica: Quer testar já o novo explorador de ficheiros do Windows 10?

A Microsoft está constantemente a melhorar o Windows 10 e a criar novidades neste sistema operativo. Muitas vezes são apenas novas versões de ferramentas que já existem, mas que agora se adaptam a novas realidades.

Há muito que se fala que o Explorador do Windows pode receber uma nova roupagem e que ser até substituído. Uma nova versão já espera a sua vez dentro do Windows 10 e hoje vamos mostrar como a podem testar.

Este novo explorador de ficheiros do Windows 10 está ainda longe de estar pronto. Ainda assim, tem presentes as funções necessárias para ser usado no dia a dia. A navegação é simples e intuitiva, havendo ainda alguns pontos a serem tratados.

Saiba como chamar o novo Explorador de ficheiros

Para testar esta nova proposta da Microsoft, os utilizadores só precisam de abrir uma janela do explorador de ficheiros. Aí dentro, na barra de endereço, devem colocar o seguinte caminho: shell:AppsFolder\c5e2524a-ea46-4f67-841f-6a9465d9d515_cw5n1h2txyewy!App. Terminem este processo carregando em Enter.

Windows 10 explorador ficheiros Microsoft ferramentas

De imediato será aberta uma nova janela, com a versão UWP (Universal Windows Platform) do Explorador de ficheiros. Este será aberto na mesma localização onde a outra janela estava aberta.

Windows 10 tem novas ferramentas para os utilizadores

Podem navegar de forma normal, carregando nas pastas ou nos ficheiros presentes. Tudo será mantido da mesma forma que conhecem do Explorador de ficheiros do Windows 10. Contudo, a interface é toda mais simples e minimalista.

Windows 10 explorador ficheiros Microsoft ferramentas

Alguns elementos podem ser alterados, como a apresentação das pastas. Requer alguma habituação à localização das novidades, uma vez que não estão identificadas. Surgem pelos ícones, que mesmo assim são simples.

A Microsoft vai melhorar esta sua nova proposta

Se quiserem manter este explorador de ficheiros sempre acessível, tal é possível. Basta carregar com o botão direto do rato no ícone presente na barra de tarefas. Da lista de opções presentes, devem escolher a opção Afixara na barra de tarefas.

Windows 10 explorador ficheiros Microsoft ferramentas

O ícone deste novo explorador vai estar presente de imediato e bastará ao utilizador clicar nele para que seja aberta a janela que esperam e procuram usar. A sua remoção só necessita do processo inverso para ser feita.

Este não é ainda um explorador terminado e lançado a ser usado. Está já maduro e principalmente pronto a ser usado em testes no dia a dia. Experimentem o que a Microsoft está criar e o caminho que vai seguir no futuro do seu sistema operativo.

Os melhores editores de vídeo gratuitos para usar online

Com os smartphones a serem cada vez mais máquinas de fotografar e filmar e com cada vez mais criadores de conteúdo para a Internet é importante conhecer diferentes propostas de ferramentas de edição disponíveis.

Para quem pretende editar vídeo em qualquer lugar, de forma rápida e gratuita, estas são algumas das melhores propostas de editores de vídeo para usar online.

Os melhores editores de vídeo gratuitos para usar online

ClipChamp

Em primeiro lugar, sugerimos o ClipChamp, uma das mais completas soluções para edição de vídeo online. Além das ferramentas de edição de vídeo, também oferece um compressor de vídeo, conversor e gravador de webcam.

A plataforma de trabalho é bastante intuitiva e dando a qualquer pessoa a possibilidade de editar com facilidade. O resultado final pode ser gravado diretamente no computador ou partilhado em qualquer serviço de nuvem, como o Google Drive, por exemplo.


Online Video Cutter

O Online Video Cutter não é propriamente um editor de vídeo, mas poderá ser uma solução útil neste universo. Basicamente é um serviço web prático para quando o utilizador necessita de cortar um pequeno ficheiro de vídeo. Além disso, suporta praticamente todos formatos de vídeo disponível. Até ao momento o serviço está limitado a ficheiros com 500 MB.


WeVideo

Além do corte e da divisão de vídeo básicos, o WeVideo permite adicionar marcadores a clips específicos ou texto simples estático e textos explicativos ao vídeo. Permite ainda adicionar transições, gráficos de plano de fundo, sobreposições e quadros.

O WeVideo encontra-se disponível online, mas pode também ser encontrado nas lojas de aplicações móveis da Apple e da Google, para iOS e Android, respetivamente.


Kizoa

O Kizoa destaca-se entre estes serviços online pelo seu amplo conjunto de efeitos e transições. Os vídeos podem ser criados a partir de diversos formatos, podendo ser adicionadas músicas, textos e efeitos especiais.

Além de poderem ser utilizados ficheiros a partir do PC, o serviço também consegue suportar as imagens disponíveis nas suas contas de redes sociais.


Windows Server 2008 – Vamos criar um domínio

Apesar de hoje em dia os sistemas operativos móveis serem o centro das atenções, há sistemas que são fundamentais nas empresas e que fazem parte estrutura da Internet.

Hoje vamos dar início a uma rubrica que terá como objectivo ensinar a instalar e a configurar um conjunto de serviços no Windows Server 2008. Hoje vamos ensinar a criar um domínio interno.

Como referido, pretende-se com estes tutoriais ensinar a explorar o Windows Server 2008 e a instalar/configurar serviços como Active Directoy, DNS, DHCP, etc. Para começar vamos ensinar a criar um domínio Interno. A elaboração deste tutoriais têm como base o Virtualbox para virtualizar o Windows Server 2008 e também algumas outras máquinas com Windows .

Para a criação de um domínio interno é necessário instalar o serviço de directório Active Directory.

Active Directory é uma implementação de um serviço de directório no protocolo LDAP, que mantêm as informações sobre os objectos que fazem parte de uma rede de dados. São considerados objectos os utilizadores virtuais, os grupos, os computadores, as unidades organizacionais, etc. (Depois de instalado o Active Directory iremos explorar melhor esse serviço).

Como instalar o Active Directory?

Para instalar o serviço Active Directory (AD) devem seguir os seguintes passos.

1) Nas Initial Configurations Tasks, carregamos em Customize This Server > Add Roles

Nota: Para aceder a esta interface, use o comando oobe.exe

ad_00

 

2) Next…

ad_01

3) Seleccionar o serviço “Active Directory Domain Services

ad_02

4) Next…

ad_03

5) Carregar em Install

ad_04

…o processo de instalação do AD demora cerca de 2 a 3 minutos

ad_05Serviço AD instalado!

ad_06

6) A configuração do AD é feita recorrendo ao comando dcpromo.exe  como referido várias vezes durante do processo de instalação do AD. Depois de executado o dcpromo, na primeira interface carregamos em Next,

ad_07

7) Next…

ad_08

8) Escolher a opção Create a new domain in a forest

ad_09

9) …e e seguida indicamos o nome do dominio que pretendemos criar. Para este exemplo vamos criar o dominio pplware.com

ad_10

10) Nível funcional ao nível da floresta escolhemos Windows Server 2008

ad_11

11) Nível funcional ao nível do Domínio Windows Server 2008

ad_12

12) Para que o AD funcione correctamente é recomendado que seja instalado o serviço de DNS no primeiro controlador de domínio (Máquina onde vamos instalar o AD)

ad_13

13) Não esquecer que o servidor deve ter um IP estático configurado. Se ainda não o fez, pode aproveitar este passo para efectuar essa configuração.

ad_14

13) Carregamos agora em YES (Depois em outros tutoriais tratamos do serviço de DNS)

ad_15

14) Indicamos os directórios onde vão ficar os ficheiros de log das bases de dados, controlador de dominio, etc.

ad_16

…Apresentação de um sumário das configurações realizadas

ad_17

…Esperamos mais alguns minutos para que toda a estrutura do AD seja configurada

ad_18

E após uns 5 minutos temos o AD instalado. Num próximo artigo iremos explorar as funcionalidades de um AD. De referir que o Windows 2008 corre bem numa máquina virtual com apenas 512 MB de RAM (no mínimo). Hoje ficamos por aqui e esperamos o feedback do vosso lado.