DEV Community: nuh yurduseven

How to personalize the shell for developers - my custom setup

nuh yurduseven — Sun, 18 Dec 2022 20:04:04 +0000

Hi, This post has been written to create a beautiful and useful custom operating system shell setup for developers, data scientists or everyone who want to have unusual linux,*nix or macos shell. This is completely simple guide for installation of shell setup for best efficiency.

install zsh and ohmyzsh

 ## for Debian/Ubuntu
sudo apt-get install zsh

## for RHEL/Centos/Fedora
sudo yum install zsh
## for only Fedora 
sudo dnf install zsh


## for arch
sudo pacman install zsh
## for mac
brew install zsh

The package manager installed the shell on the system.

to install ohmyzsh latest version:

#using curl
sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"
#or using wget
sh -c "$(wget https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh -O -)"

ohmyzsh installed under the /home/user directory as hidden. You can see the folder .oh-my-zsh and .zshrc config files. ohmyzsh will change zsh config file contents.

change the theme

Open .zshrc* config file with nano or vim and change themes:

nano ~/.zshrc
#or
vim ~./zshrc

ZSH_THEME="fino-time"

You can find different themes from the pages

install custom plugins

zsh-autosuggestion

git clone https://github.com/zsh-users/zsh-autosuggestions.git $ZSH_CUSTOM/plugins/zsh-autosuggestions

zsh-syntax-highlighting

git clone https://github.com/zsh-users/zsh-syntax-highlighting.git $ZSH_CUSTOM/plugins/zsh-syntax-highlighting

zsh-autocomplete

git clone --depth 1 -- https://github.com/marlonrichert/zsh-autocomplete.git $ZSH_CUSTOM/plugins/zsh-autocomplete

And add these to plugins tuple in .zshrc

plugins = ( git
            sudo
            zsh-autosuggestions 
            zsh-syntax-highlighting 
            zsh-autocomplete
            )

install pyenv for python version control

Pyenv is a tool which can manage python environment and versions. It's very useful tool for all types developers.
To installation the tools:

git clone https://github.com/pyenv/pyenv.git ~/.pyenv

and to define environment variables:

(for zsh)

echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.zshrc
echo 'command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.zshrc
echo 'eval "$(pyenv init -)"' >> ~/.zshrc

after that:

exec "$SHELL"

To create python virtual-environments, virtualenv plugin installation is required.

git clone https://github.com/pyenv/pyenv-virtualenv.git $(pyenv root)/plugins/pyenv-virtualenv

Usage

You can install many of python, conda versions with this tools easily. You can check github repositories for more information.

## install a python environment
pyenv install 3.8.5 
## create a virtual environment
pyenv virtualenv 3.8.5 myenv

after create a virtual-environment, it's usable with this command.

pyenv activate myenv
(myenv)$

Using Rstudio with windows subsystem for linux(wsl)

nuh yurduseven — Tue, 11 Jan 2022 19:55:42 +0000

Hi, In this post, I gonna show you how to install Rstudio on wsl system and to reach over the browser. if you are using windows and dont want to use Rstudio client in windows-side, this method will work perfectly.

Install windows-subsystem for linux

Open the Microsoft store and search "wsl" or "ubuntu" In windows store, There are many windows subsystem for linux distributions such as Ubuntu, debian, suse, kali, alpine wsl etc. You can use one of these distributions.
Installation can be done using the instructions in the terminal.
Determine username and password for linux subsystem.
You can use windows terminal or any terminal emulator for windows.

Note: It can be used graphical linux application via wsl2. wsl1 is not supported that. But you must install X window manager to use graphical application on wsl2. You can use rstudio desktop on wsl2 with this way.

Install R and Rstudio-server

In this stage, you should install Rstudio-server to subsystem side and you can install R environment to linux side as well. This is absolutely great trick for those switching to windows from linux.
For ubuntu or debian:

$ sudo apt-get install r-base
## after the instalation of R environment
$ sudo apt-get install gdebi-core
$ wget https://download2.rstudio.org/server/bionic/amd64/rstudio-server-2021.09.2-382-amd64.deb
$ sudo gdebi rstudio-server-2021.09.2-382-amd64.deb

After the installation, You can start rstudio server via

$ sudo rstudio-server start

To reach in windows side with browser

R environment and Rstudio server are installed and server is activated. you can access Rstudio from browser in windows side. Rstudio is working on localhost server and it can be accessed via browser http://localhost:8787 address.
To access the server, you have to have a username and password has been determined before. You can use the username and password you used during the installation of the subsystem.

Conclusion

Using this method is absolutely great for those switching to windows from linux. Linux is more simple and more useful but using windows os with linux subsystem is quite influential. This method is used for any environment such as using python environment and jupyter notebook together.

How to Create GUI for remote server with i3 window manager

nuh yurduseven — Sun, 05 Dec 2021 16:23:02 +0000

Hello there. This article is about providing management via a UI by installing a window manager or desktop environment for servers and establishing a remote connection. A graphical server and desktop environment are not used on remote servers because server resources are usually limited. In this post I will be working on a remote server with i3, a lightweight window manager.

Note: Instead of a remote server, I will prepare a virtual server by giving a random IP on my own computer with Vagrant and perform the operations. This is how you can make your first attempts.

What's i3 wm

For operating systems based on the Linux kernel, the graphical interface does not directly belong to the operating system. It is a module that connects to the operating system like any application. In this way, a crash on the graphics side does not affect the operating system. It is sufficient to resolve the graphics server error and restart it.” X Window” is a widely used graphics server developed in a very flexible way. Most current and known distributions use Xorg as graphics server. It contains a "window manager" inside. Its task is to organize operations such as screen layout of windows, adjusting the size, creating virtual desktops. Enlightment, Blackbox, kwin in kde and i3 etc… These are examples of window managers. i3 window manager is very light (1.2mb) and easy to use thanks to keyboard shortcuts. This is an alternative to install on your remote servers that are not very resource rich.

Installing Ubuntu server via vagrant(optional)

With Vagrant, you can create a virtual server on virtualbox and work on this server. After installing the appropriate vagrant version and oracle virtualbox application for your system, you can create a vagrant box and work as if you were working with a machine with a static IP.
Click the link to download vagrant

“vagrant boxes” describe operating systems that are installed and ready to be used. After downloading and creating a vagrant file on “Vagrant cloud”, it can be raised with vagrant.

With vagrant box add {title} or {url}, you can download a new vagrant box from the new cloud. You can check with vagrant box list, create a vagrantfile with vagrant init, and raise the server with vagrant run. If different configurations are required, you can create vagrant fie manually and then raise it with vagrant up.

Let's download the ubuntu box, which is in the first place on the cloud.



$ vagrant box add ubuntu/trusty64

After checking if it is in the list, let's save the following vagrant file with the name Vagrantfile in the directory we are working in. It can then be lifted up with vagrant up. You can send a "shut down" signal with vagrant halt to turn it off.



NAME = "remote-Server"  
IP = "192.168.1.XX"

Vagrant.configure("2") do |config|  
  config.vm.box = "ubuntu/trusty64"
  config.vm.hostname = NAME
  config.vm.network "public_network", ip: IP

  config.vm.provider "virtualbox" do |vb|
    vb.customize ["modifyvm", :id, "--memory", '2048']
    vb.name='remote-server'
  end
    config.vm.provision "shell" do |s|
    s.inline = "echo Server created succesfully!"
  end
end

The IP given here is an IP address in the internal network. The virtual machine is a different computer in the internal network and is connected with a bridge adapter.

Select your bridge adapter after the up command. Wifi or ethernet adapter. You can see the hostname and username information, and other information...

Once it's up we can connect via ssh.



$ ssh vagrant@192.168.1.X

password: vagrant
and we are inside...

Installation of xserver and i3 wm

If your server does not have a graphics server on it, it must be installed before i3. You can check it with startx. It is a shell script that runs xinit.

Xorg and openboxshould be installed on Ubuntu. It is available in the Repository. You can install them using “apt install”. You can find x graphics server installations on Centos, opensuse, fedora or bsd based systems in user guides, wiki pages and forums. (stackoverflow, superuser, stackexchange etc)

Afterwards, the i3 package in the repository can be downloaded and installed.

Then the graphics server should be started using the startx shell script.

If you do not have limiting factors such as memory and storage space on your remote server, you can use "xfce desktop environment". This “DE” has a clean interface and uses very little resources.

Connection of Server

There are different options available at this stage. You can make a remote connection and manage the system with the "remote connection" application you want. You can select an application that you can connect with the operating system you use and the operating system you use on the remote server. Tools such as teamviewer, anydesk, tigerVNC, tightVNC, realVNC, remmina, zoho assist, Apache Guacamole, NoMachine, xrdp, freeNX are widely used. Here we come across SSH, RDP and VNC as protocols. SSH (Secure Shell) is a secure remote connection protocol.RDP (Remote Desktop Protocol) is a protocol developed by Microsoft that enables connection with the graphical interface of remote windows machines. VNC (Virtual Network Connection) is a platform-independent, server-client architecture protocol that allows to manage applications on a graphical interface running on any network server with a remote connection. You can use any of the above tools for remote control.

Apache Guacomole is a little different. Because it has a client-less structure. After the installation on the server side, the connection can be established and managed via the web browser of any computer.

You can use one of the advanced software mentioned above or other than these. But I will use a vnc application to be lightweight. The packages required on the server side are i3 and xorgfor Ubuntu server. Apt will automatically install the dependent packages. Firefox and vim can also be installed. These packages should also be installed in distributions such as Centos, SUSE, Arch. Package names may be different in the repository, but basically a graphical server driver and a window manager or desktop environment are needed.



$ sudo apt install xorg i3 firefox vim

Then tightvncserver should be installed.



$ sudo apt install tightvncserver

Then the server should be started with the vncserver command. At this stage, vnc password should be determined, if needed, password can be set for view-only mode.

It gives each session an id and to kill the session;



$ vncserver -kill :session_number

Connection can be made by using any client application that supports vnc on the client side. realVNC or remmina etc. applications can be used.

In order to have a secure connection, tunneling is done with ssh on the client side. 5900+N port is the default vnc port. Here N stands for the screen number. So more than one X session can be connected. Default port + session number is to make it easier to manage.



$ ssh -L 5901:127.0.0.1:5091 -C -N -l username ip_addr

You can monitor whether the connection is established with netstat.(It may differ in some distros. For example, on Solus, the ss command does the same job as netstat.)

Then, it is sufficient to select the VNC protocol onRemmina and connect to the localhost:5901 port. Then the connection can be established with vnc password.

It offers an option to change the config file at first launch or to use it with its default settings.Alt+enter is used to open terminal with default settings. Alt+h can be used to split the new window's position vertically, alt+v to split it horizontally. You can learn the usage information in detail from the user's guide on its web page or from the blogs. Below is a firefox browser, active processes and a terminal.

vncserver can be made into a systemd service. In this way, vnc session can be started at every system startup.

It can be used in a lightweight "desktop environment" like xfce instead of a "window manager". You can integrate it by making some changes in the configuration settings…

Create a systemd service for Flask API(for GNU/Linux distros)

nuh yurduseven — Sun, 05 Dec 2021 12:49:16 +0000

Hello… in this post, I want to show you something about a productivity trick in server side. I will talk about the systemd package on Linux systems, which will be used in the application development process or for custom.

First of all, systemd is a software package included in linux operating systems, according to Lennart Poettering… He is the author of the package software.

It is created by the init process and takes 1 as the process id (pid). systemd services are started automatically and can be managed by root users. With the sytemctl command, systemd services can be started (start) and stopped (stop), applications that have changed configuration files can be re-read and restarted (reload), the status of the process can be obtained (status), and its activation can be controlled after the system restarts ( enable/disable). For more information, see the manual page.


 bash
$ man systemctl

Flask microframework is a very easy-to-use framework software for creating simple APIs. To add it to your script file, it is sufficient to download the flask module with pip3 and include it on the page, and create an app object to create your routes. Then the script below can be used.



import flask
app = flask.Flask(__name__)
app.config["DEBUG"] = True

@app.route('/', methods=['GET'])
def function_one():
return "<div style=\"   display: flex;justify-content: center;align-items: center;height: 100%;border: 3px solid green;  \" ><p>Hello sir, It seems to work properly.Here is<span style=\"font-size:50px; color:white; background-color:red\"> / </span></p> </div>"

@app.route('/users', methods=['GET'])
def function_two():
return "<div style=\"   display: flex;justify-content: center;align-items: center;height: 100%;border: 3px solid green;  \" ><p>Hello sir, It seems to work properly.Here is<span style=\"font-size:50px; color:white; background-color:green\"> /users</span> </p> </div>"

@app.route('/products', methods=['GET'])
def function_three():
return "<div style=\"   display: flex;justify-content: center;align-items: center;height: 100%;border: 3px solid green;  \" ><p>Hello sir, It seems to work properly.Here is<span style=\"font-size:50px; color:white; background-color:blue\"> /products </span></p> </div>"

app.run()

By default, it starts working on the localhost:5000 port. To change port or host, you can give new host and port with app.run(host='ip_addr',port='port' ).

After the script is saved as app.py, it can be converted to a systemd service by writing the systemd service.

When a flask application is run with python, it is raised on the "development server". There are different options for the API to be raised in the "Production" environment. You can learn from the Flask manual page.

Check it out flask Deployment options

Depending on the operating system, sudo vi /lib/systemd/system/myFlaskApp.service or Let's open it in nano editor. This path may differ depending on the distro. To find out where other services are, e.g. for mariadb service,



$ locate mariadb

If there is no output, use the updatedb command and try again. services can also be found under /usr/lib/systemd/system/… Or you can create such a directory under the /usr directory.

/lib/systemd/system/myFlaskApp.service =>



[Unit]
Description=My flask API service
[Install]
WantedBy=multi-user.target
[Service]
Type=simple
User=your username
PermissionsStartOnly=true
ExecStart=/usr/bin/python3 /your/path/app.py
Restart=on-failure
TimeoutSec=600

Note: Here we set Restart=on-failure. This indicates that we only want it to restart when the exit code is not 0. We can also add Restart=always and RestartSec=1 lines instead. It makes it reboot in any case.
You can add a config file with sudo vi /etc/init/myFlaskApp.config.



description "MyFlaskApp"
start on stopped rc RUNLEVEL=[2345]
respawn
exec python3 /your/path/app.py

Then,



$ sudo systemctl start myFlaskApp

You can start the service with this command. Make sure it is in the active(running) state with systemctl status.

This method can be useful for developments made on the cloud service, but it is recommended to use the deployment options above in terms of both performance and manageability in the production environment.

This service runs in the background without user intervention. It takes a pid as can be seen with sytemctl status. If a modular API structure is created and the route operation and other operations are isolated from each other, this method may be useful in situations where no modifications to this file are required. In this way, we can call it “life hacking”. To use something as the meaning of the word to improve a lifestyle other than its purpose…

You can make processes like this or that don't need to be interfered with by your system as systemd service and control them with systemctl.

Review of Data Science Platform Tools -KNIME Analytics Platform(Section 1)

nuh yurduseven — Sun, 31 Oct 2021 20:24:25 +0000

Hello, In the first article of the series, where I examined the data science software that I decided to be a series and I will support it with applications, the installation of the KNIME application, which is written in Java and built on Eclipse, and which can prepare data science and artificial intelligence applications with workflow-style visual programming, its configuration on widely used GNU/linux systems. and I will review its usage with a machine learning application. I plan to save the application I prepared and share it in a github repo.

KNIME

KNIME Analytics is a data science environment written in Java. This software allows visual programming in the form of a workflow using various nodes and is an application that allows to develop a data mining application even without knowing advanced coding. It has a very diverse and rich plugin center and is used quite often in academia as well. It is an extensible data science platform where user-created scripts and codes can be used as well as visual programming. KNIME is cross-platform software that supports installation on many operating systems. You can click link to download. In this article, I will review KNIME for GNU/Linux distributions only.

Configuration

You can extract the tar.gz archive of the KNIME application to the desired location.

~$ tar xvf knime-analytic-?.?.?.tar.gz -C /opt/knime

All libraries and plugins of KNIME are available in the directory. There is a binary file named Knime and you can start the application using it. But it needs java to work.

JAVA 11

KNIME Analytics works with Java 11 and higher. For this reason, you can install one of the openjdk-11 or openjdk-latest packages for KNIME. Depending on the distribution you use, you can easily download and install these jdks from the main repository.

For example, for RHEL based ones;

~$ sudo dnf/yum install java-11-openjdk # or java-latest-openjdk

Or Debian based ones;

~$ sudo apt install openjdk-11-jdk # or default-jre

Another option I can suggest here is the libertica jdk versions published by Belsoft. These are opensource and freely distributed java jdk versions. You can download and install jdk with many options such as standard and full package. You can find installation scripts or archives on this page for many operating systems. For KNIME Analytics, standard jdk-11-lts is sufficient. For Linux, we need to download the tar.gz package and extract it to a directory. Then the JAVA_HOME and PATH variables are updated and the java installation is completed.

~$ mkdir -p ~/libertica-jdks
~$ tar xvf /path/to/downloaded-jdk.tar.gz -C ~/libertica-jdks/

~$ export JAVA_HOME=~/libertica-jdks/jdk-11.?.?
~$ export PATH=$PATH:JAVA_HOME/bin
## after this
~$ java -version

JDK is available in this session. If you want to use it in this location all the time, you should add the lines exported for JAVA_HOME and PATH to your .bashrc or .zshrc file if you are using zsh.

After the Java installation, it is sufficient to go to the directory where knime is installed and run the ./knime script. If you have more than one jdk installed on your system, you can specifically give the path to jdk-11 with ./knime -v /path/to/jdk-11/bin.

If you want to create a dektop entry for this;

[Desktop Entry]
Type=Application
Name=KNIME Analytic Platform
Description=Data Science Environment
Exec=/path/to/knime-folder/knime_4.?.?/knime
Icon=/rpath/to/knime-folder/knime_4.?.?/icon.svg
Categories=Development;Science;
terminal=false

You can create a file named ~/.local/share/application/knime.desktop and save the entry to the relevant location.If you have problem with exec command. You can give a shell script that runs the ./knime script as a parameter in the exec command. If you are using wayland as a display server, you may have problems in the application. For this reason, you can add the line export GDK_BACKEND=x11 to your configuration file bashrc or zshrc or whatever shell you are using, or inside your script file that starts KNIME. If you're already using x11 you won't have any problems.For example, the shell script that starts KNIME;

#/bin/bash
export GDK_BACKEND=x11
./knime -v /path/to/java-jdk-11/bin

may form.

Extension installations

The KNIME application had many extentions. The high number of users and its extensibility are the most important factors that bring it to the top among other data mining applications. You can open the interface by selecting Install KNIME Extensions... from the File menu in the application. You can install it by searching for the add-on you want. For example, you can install the KNIME twitter connector plugin that should be used to connect to the Twitter API and pull data. It will be installed with the necessary dependency packages. The application will need to be restarted before it can read new plugins.

Then you can search for the node you want from the Node Repository section and add it to your project.

Machine Learning Application with KNIME

In this section, a ready-made dataset will be used to prepare a machine learning application. A data mining workflow will be created with KNME nodes by using the dataset named HCV Data Dataset in the UCI Machine Learning Repository. The project is created with new project from the File menu. Node Repository
I add my file to the project by searching file reader or csv reader from the section. Similarly, I search for the transactions I want to do in the Node Repository and add them to my project and run them, and at the end of each operation, I give the output as the input of the next node.

When I right-click on the nodes, I configure the operation and then run it. When I right-click again, I can see the output of the node as a result of the operation under the menu. The Normalize node below outputs the normalized table and model.

The operations performed in this application can be seen as follows.

In the application, the data in the csv file was first read with the csv reader node and the categorical values such as sex were given to the category to number node to be converted into numbers. The output of this node is given to the column filter node to extract the Id and categorical gender values. The output dataset is given to the Normalize node. The dataset with 0-1 normalization was given to the Partitioning node to be divided into 70% training and 30% testing. A model was created by giving the training dataset from the parts to the RProp MLP Learner node. This model and test dataset was tested by giving it to the MultiLayerPerceptron Predicter node. And the output of the node has been transformed into a table with the comparison matrix and score values related to the performance in the Scorer node.

When our perceptron model was tested with 1 hidden layer and 10 neurons, it was seen that our comparison matrix and performance values, respectively;

It seems to be a very successful model, here the dataset was not raw data. The performance of the data preprocessing on the data set was 98% accuracy. Preprocessing is definitely a important factor for model performance. If you create a model with the raw data set, you can see that you cannot achieve a high success.

Due to the preprocessing of this dataset;

reviewed with R
Sample dataset review with Smote
Outlier cleaning with R boxplot
Second time dataset with SMOTE balancing

You can find this project and its dataset in the repo in the link.

Resources and project

How to make a static web sites using Hugo-Github Page

nuh yurduseven — Sat, 25 Sep 2021 18:38:59 +0000

Hello, In this article, I will cover creating simple static websites with hugo, a static website creation tool written in golang, hosting and publishing them on github. For this, I plan to prepare two different websites and use different third-party web services that will be useful to us while preparing them. First of all, I will talk about the use of hugo and then I will continue by creating a simple website.

Hugo

Hugo is a static web-site generator written in Go. This framework can quickly create a static website with terminal commands, thanks to a freely installed and available CLI tool. It also has different deployment options. In the hosting and deployment section of the gohugo.io site, it is explained how the website can be hosted on different web hosting platforms. But in this article, I will build a website that will be hosted on github and run in the domain username.github.io.

To download the framework and for a quick start, you can go to gohugo.io to install it on your system and start right away. If you are using a GNU distribution, the package is probably in your repository. On ubuntu and debian repositories hugo can be installed with;

$ sudo apt install hugo

On Fedora repositories hugo can be installed with;

$ sudo dnf install hugo

In hugo official website, it recommends installation with homebrew for both linux and mac. You can use the code below for Homebrew installation;

$ /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Then you can install hugo on your system with brew install hugo

After the installation, You can create a new web site with

$ hugo new site /path/to/your/site

on terminal.The file hierarchy is as follows. The config.toml file is the file that allows us to configure the website.

Now, this will open a blank page. Because there is no file in the layout.
You can clone one or more themes by selecting them from gohugo.io/themes and using git into the themes directory. using hugo new content/new_article.md it can be used to create a new content.

The website will start working on local server 1331 port with

$ hugo server

If you want to take your experience further, you can create your own design by using the template tutorial on gohugo.io. But in this article, I will only create web pages using ready-made templates.

Creating a Static Portfolio Page

Portfolio pages are one of the best examples of static pages. These are the types of pages where the works done are exhibited and other accounts or communication e-mails are given as links. To create it, I first need to clone it with git by selecting from the portfolio themes listed on the themes.gohugo.io page. I choose the theme named hugo-shell-theme. One of the reasons why I prefer it is that it has a very simple structure. I will make my first attempt using this theme.
I'm clonnig the theme into themes directory with

$ git init 
$ git submodule add https://github.com/Yukuro/hugo-theme-shell.git themes/hugo-theme-shell
$ hugo server -t hugo-theme-shell -w -D

and starting the hugo server.It is currently running on the local server, but without any configuration. for this, I copy the content of the config.toml given on the github page of the theme and paste it into my config file in the directory. Below is the config file where I changed some parts and deleted the comment lines. I preferred powershell as shema.

It gives me an output like this:

For a better use, you can try to use a markdown file in the description. For example, you can find the portfolio website I use at noaahhh.github.io.

For Markdown usage, a description.md created in content is given to the description section of the config file.

description=/description.md

Then you can fill out whatever you want. If you go to the code side, you can see how it takes the parameters from the config file between the html tags.

Likewise, now I'm cloning the hugo-profile theme into the themes directory with git. This theme uses config.yml with .yaml extension as config file. I copy one of the 3 different yaml files (v1.yml) in the theme directory to my root directory as config.yml. And content of the website directory must be copied root directory. Our website is using the new theme on the local server after the command below.

$ hugo server -t hugo-profile -w -D --config=config.yaml

In this theme, you can also create your personal website by changing the parameters in the config file. In the following sections, I will talk about a more user-experience-oriented method.

e-commerce and product presentation pages

In this section I will try the Hero theme. Hero has a familiar type of company landing page and a clean interface. That's why I chose this theme. I'm creating a new website with Hugo. Then I clone this theme with git into the theme directory. There is a directory named example-site in the theme. This directory contains a pre-configured toml file and a ready-made website. I copy the contents of this directory to my home directory. Then I open my config file with an editor and delete the themesDir parameter. Then I can run hugo server and watch my website from localhost port 1313.

I've added an image below listing the terminal operations performed. You can check.

This way you can create websites to promote products or for a company portfolio.

Github Pages

There are multiple options for hosting a website built with Hugo. You can see the host and deployment options from the Hosting&Deployment link. We can host our website with services such as github, gitlab, netlify firebase. In the Github option, you can access the page we created via the username.github.io domain. In this application I will work on github.

We can publish our portfolio site, one of the websites we have prepared so far, on our own github domain. For this, we go to the directory where our portfolio website is located and create our website with the hugo command in this directory. A public file will be created in the directory and there will be our website using html to be published in this directory. If we submit it to our git repo within this directory we can publish our website using Pages there. We go to the Github page and open a repo named username.github.io.

We are connecting the public directory created according to the diagram above to our relevant git repo.

myHugoSite $ cd public
public/ $ git init 
public/ $ git remote add origin https://github.com/username/username.github.io.git
public/ $ git remote set-url origin http://<public-access-key>@github.com/username/username.github.io

After the last changes, to connect to our git repo, you should create a key by following the github->settings->developer Settings->Personal Access Key path and paste this key in the relevant section in the last command to link our repo.

public/ $ git add .
public/ $ git commit -m "initial commit"
public/ $ git push origin main

Then we can wait for it to be published from the setting-> Pages section in our repo. Our site will be published from the relevant url.

Different architecture for GitHub

If we want to publish our website over a subdomain with the same name as the repo, we can open a new repo and send the files in the public to this repo and publish it. If we examine the diagram below, we can create a website in our local system and keep this site on github. We can create a submodule link from another git repo in the "themes" directory. We can publish our files to be published with Github Pages by sending them to a new repo using the subdomain name to be published.

You can create a submodule with

mySite/ $ git submodule add http://github.com/Yukuro/hugo-theme-shell.git themes/hugo-theme-shell

mySite/ $ hugo -d ../myPortfolio

We can create html files in a directory called myPortfolio, which is in the same directory as our hugo website using like the command above.Then we can link this directory to the github repo and publish our website on a subdomain with the same name as the repo.

Hugo and Forestry.io

Forestry.io is a web service that makes it easy to manage the contents of our website on github using a graphical interface. This service is a CMS tool that works with frameworks such as hugo, jeykll. Content entry in personal blogs can be done easily. You can get more detailed information on the page.
It has a simple use. We just have to register for the service and then create a new registration with add site in the "My Sites" section and select Hugo as the "static site generator".

And then we connect our repo with the forestry.io service by choosing git provider.

Then we can prepare our posts in the blog in the document types we choose.

Apart from this, there are many CMS applications that work with Hugo. Cloudcannon, strapi.io, netlifyCMS can be given as examples. These are the systems we can use to organize our content between host and deployment.

The loop in the diagram represents the CMS service. With CMS services, operations such as content creation and editing can be done before deployment. By connecting with services such as AWS, Netlify, content editing can be done between the git provider and the deploymet service. And at the same time it provides synchronization with the website maintained in git.

This is my basic portfolio designed with hugo

nuh yurduseven — Fri, 10 Sep 2021 17:22:24 +0000

Hi, I created a simple portfolio page using Hugo and hugo-theme-shell. This is quite simple and very attractive according to me. I am interested in all about operating system because of this reason I prefered to design like shell. This is very simple form, I am going to develope the site. You can click the link if you want to check it out. What are your thoughts? Please write below.

How to create cold storage wallet using usb memory stick

nuh yurduseven — Wed, 08 Sep 2021 18:42:20 +0000

Hi, today I'm gonna teach you how to create a cold-storage wallet for bitcoin or other crypto-coins using usb memory and tails.

Tails, an operating system based on Debian and providing anonymity by routing all network traffic through Tor, will be used as the operating system. We will examine what features are available in some security-oriented distributions.
Let's dive the content.

Cold-wallets vs Hot-wallets

Cold wallets are a type of wallet that is used to store your private key and other information on hardware that does not have an internet connection. As another type, paper wallets can also be considered as cold wallets. Here, only the private key and the information that will enable us to reach the total balance in the blockchain are available. Examples of hardware wallets are ledger and trazor. These are electronic devices similar to USB sticks that are configured to generate public and private keys and are used to store keys with the highest level of security. It can be ordered and used within a certain fee. On the other hand,hot wallets are the type of wallet where the private key you will use to access your account on the internet is stored in a cloud-based wallet. This one is more insecure than the other but faster. Security in these types of wallets depends on measures taken by the provider of the wallet application, such as two-factor authentication. On the other hand, the security of the provider database also depends on the security measures that the wallet provider can take. This service, offered by many crypto exchanges, makes it easy to use money.

It's good to say it again. Cryptocurrency is not a phenomenon that is stored like physical money. The amount transferred from one account to the other account is recorded in the blocks in the data structure, which is in the form of an interconnected list called Blockchain, and is added to the end of the block as a result of the transactions related to the operation of the blockcahin network. In other words, this database does not have an architecture where the amount of money and other information of any account is kept in an object as in banks. For this reason, crypto money cannot be stored in any hardware. The entire blockchain can be downloaded to disk by downloading the bitcoin core for bitcoin. This is the safest method. But as of August 4, 2021, the chain size is 349.3 GB. For this reason, this method is not preferred except bitcoin miners.

Tails

Tails is a GNU/Linux distribution with Debian-based security customizations. This system is often used by cybersecurity professionals as a portable and secure operating system. In the crypto world, many people use this method to access and manage their money on the blockchain. You can click the link below to download Tails.

Tails operating system is configured to be more of a portable system. The Internet connection can be routed through the Tor network. At the same time, the system can be "persistent" so that the files can be saved to the USB memory, and this section is encrypted to provide security. It should be noted that using the Tor network does not provide complete protection and complete invisibility. This is one of the common mistakes made by groups called “Lamer” or “Script Kiddie” in cyber security. Every system running on the Internet may have a security vulnerability. That's why it's still good to be careful. However, I believe that it can be quite useful as a cold wallet if used carefully.

Installation on usb stick

After the iso is downloaded, the iso can be written to a usb stick. You can use dd or etcher or any of the rufus software for this. Then the system is started via USB memory. At the first boot, the basic language-keyboard settings are taken and configured and the live system is started in this way.

The method I use will be to create a kvm-qemu virtual machine on the host I use, and select and add the USB memory connected to the host machine with the virt-manager visual interface from the hardware list and start it from the boot menu on this device. Installation in a virtual machine is not recommended by tails. You can even detect that tails is running on the virtual machine and you will see a warning message. However, there will be no harm in doing the first installation in this way.
The system works on usb but is still a live system.

Make persistent and encryption

For this feature, it can be used by encrypting the part that the system does not fill on the usb memory with the configure persistent volume option from the application menu. This section can be used with this password when you set a password and start the new system, but you can use this section as a live system without opening it.

Cold-wallet configuration

Tails comes with electrum bitcoin wallet installed. To use this wallet, the Bitcoin client must be activated from the configuration persistent volume application, so that the configurations and other data of this application can be saved in the persistent partition. A reboot is then required.

The necessary configurations can now be made by opening the Electrum wallet.

Electrum wallet is a very common wallet application. It can be installed on any machine, but in this way it will provide a safer use. First, the wallet must be given a name.
Many options are available in the next menu. If you have a standard, 2-factor authentication, multi-signature or previously prepared wallet, you can import it.
I will create a standart wallet.

In the next option, it is necessary to create a new seed. This is an algorithm that generates the private key. It generates a list of 12 words and this list represents your private key for you. You must record these words in order.

Do not share these words with anyone

In the next step, it asks you to enter these words in order. It then asks you for a password to re-encrypt your wallet.

You can see the public key and other information of the wallet from the "Wallet information" tab.

Now you can start using…
It is necessary to use different wallets for other cryptocurrencies and tokens. For this, you can download and download different wallets and install them on the system.

Other security orianted GNU/Linux OS

Linux Kodachi is also a tails-like system but is a newer distribution. It routes network traffic through VPN and Tor. It can be installed on USB memory or DVD. Likewise, this is a Debian-based distribution.

Whonix is an operating system with a Debian-based Tor network and a security architecture based on isolation. Whonix consists of two parts: One runs only Tor and acts as a gateway, called the Whonix-Gateway. The other part, called Whonix-Workstation, is on a completely isolated network. Only connections through Tor are possible. It is one of the recommended distributions in the Cubes system. Security is provided by increasing isolation with virtualization on the Xen kernel.

Some distributions such as Kali, Black Arch and Parrot are distributions where the test tools needed for offensive and defensive security are collected. These come pre-loaded with many tools such as metasploit where known exploits are collected, medusa which is a brute force tool, nmap for network scanning, wireshark and sqlninja.

How to create a portable BSD-nomadBSD

nuh yurduseven — Wed, 08 Sep 2021 08:29:18 +0000

Hi, in this article, I am going to create a portable bsd operating system, nomadBSD. It's quite useful and have a simple usage. Let's dive the content.

BSD is a high dimensional system. FreeBSD uses about 40GB while noamdBSD needs about 5GB or more in workspace.This system is also based on FreeBSD,however, as a result of improvements and changes, nomadBSD, a portable "persistent" and low-size bsd distribution, has emerged.

BSD and derivatives

BSD, or Berkeley Software Distribution, is a plug-in chain created by the University of California for AT&T's unix. Derivatives such as FreeBSD, OpenBSD, NetBSD, DragonFlyBSD refer to unix-like operating systems. These systems are licensed systems and their license is referred to as a BSD license in the literature.These are complex operating systems such as GNU/linux distributions.The most popular BSD distribution is FreeBSD, and many BSD distributions are based on this distribution. BSD operating systems are extremely powerful and are the operating systems that power many servers.It is stated that BSD operating systems are more performant and in most cases noticeably faster than GNU/Linux distributions. In addition, since it is much older than the Linux kernel, it offers a more stable user experience. Although the development speed is slower, the control of the code by a single architect at the top is the most important factor that ensures the stable operation of the code.In many GNU/linux distributions the code in the master branch is not controlled by one person and many people can change the code. BSD systems can also use linux packages or window managers familiar from GNU/linux distributions. For this reason, there may be many more software packages available on BSDs.

installing & configuration nomadBSD

nomadBSD is a minimal operating system that can be used as a live-system, "persistent" and ready to use directly with installation, automatically detecting hardware. 1.2GHz CPU speed and 1G of RAM are recommended as basic requirements. Although it is not very performance for usb-2.0, it can be used much more easily with usb-3.0 and above technologies. It was a very pale expectation to expect performance from an operating system that is already persistent and carried on usb. You can boot by selecting your own USB from the boot menu of any machine, and the operating system recognizes the hardware and initiates the system boot process.

You can download the system using the link.

Here, it is explained how to open the archive and how to write the image to the USB memory according to different operating systems. It can simply be written to a usb stick using the dd tool on any operating system.

Then you can customize the system with the setup wizard and install it on the usb. Disk encryption feature can be activated optionally during installation. During boot, it waits for you to enter the password you set to connect the disk and continues the boot process after matching.The system is a persistent system. At the first startup, the installation takes place with the installation wizard, and when the system is restarted, many software that may be needed for daily use such as browser, text-editor, ftp client, a simple code editor, mail client will appear pre-installed.Since the system is based on freeBSD, the package manager is pkg. With this command, the system can be updated, the desired package can be installed and removed. The system uses Openbox as the window manager. The lightness and speed of this system is a chosen detail.In addition, as seen here, window managers or desktop environments used in linux systems can also work with BSD. When you want to install FreeBSD, you can install without a window manager, then you can install desktop environments such as xfce4, kde, gnome in the pkg repo.

Installation and review on Oracle Virtualbox

If you want to use it by creating a virtual machine on Oracle VirtualBox, there is a dedicated section in the NomadBSD manual for this. img extension archive is converted into a virtual disk with vdi extension with VBoxManager.

$ VBoxManage convertfromraw nomadbsd-130R-20210508.amd64.img \ 
nomadbsd.vdi --format VDI

Then the disk size can be adjusted again with the same tool.

$ VBoxManage modifyhd nomadbsd.vdi --resize 10000

Then, after creating a new machine on VirtualBox and making the necessary system settings, this vdi virtual hard disk can be connected to the machine.
At the first startup, the installation wizard welcomes us. Nothing is visible except the wizard.Do not close the window. otherwise you may have to restart the system.

Language and keyboard layout selection is made. It prompts again to add a second keyboard layout. You can skip adding.
After the timezone selection, the root password is determined. Username is preset as nomad.

You can encrypt the disk with the block encryption option with Geli. You need to set a password for this. This password is used before connecting the disk during boot.

Then the applications and shell to be used by default are selected. In summary, the actions to be taken are examined and the system setup is started by pressing the "Commit" button. The installation process is completed quickly. When we restart, boot is started by selecting multiple users.

Geli password is entered for disk encryption and disk binding is performed.
If you are using a USB memory stick after the system is turned on, you can make the network connection from the icon in the upper right.

Many packages that may be needed for daily use come preloaded. Many toolkits such as visual editor, office suite, mail client, a package manager with visual interface, firewall come pre-installed. You can install many packages with the pkg package manager. For example, neofetch package was installed from pkg package repositories below and dangereous from ohmyfish themes was used in fish shell.

Like all BSD systems, this is a very similar system to the GNU/Linux distributions that the average linux user can easily get used to. The system is especially configured so that even beginner users can use it easily. For example, you can perform package update, deletion and installation operations with OctoPkg graphical package manager. Here you can uninstall apps that come pre-installed but you think you won't be using.

To install linux packages on NomadBSD,

$ sudo -i
$ sysrc linux_enable=YES
$ service linux start

You can use these commands on shell. Then you can install the linux packages in the pkg repository with the following command.

Tools and databases such as Java, docker, vagrant, mongodb, elasticsearch are also available in freeBSD repositories. It can be easily installed using the pkg package manager. It is also possible to install this system on disk. But for me, a freeBSD installation would be much more convenient for a workstation or a personal desktop computer. This system is a stable and freeBSD-powered operating system designed as a lightweight alternative. For this reason, if heavy work needs to be done, a freeBSD desktop would be a more appropriate and less tiring choice.

For those who want to switch to the BSD side with this distribution, I recommend that they start with GhostBSD first. They can then switch to FreeBSD and OpenBSD which is famous security-oriented operating system. This sorting will greatly reduce the feeling of unfamiliarity in the transition process.

Using multiple GNU/Linux at the same time-Bedrock Linux

nuh yurduseven — Fri, 30 Jul 2021 12:55:47 +0000

Hello, in this article, I will talk about Bedrock Linux, which is a daemon that allows to use software packages from more than one package manager, while also installing and using multiple distributions in layers. Although it is described as a separate Linux distribution, we can say that it is a daemon that connects the distributions installed to the root directory and then installed in layers, to the root directory. This is a system that allows to use multiple different software packages together with a very useful and customizable architecture.

In order to understand this architecture, I will first talk about the linux system hierarchy. Next, I'll review the bedrock Linux hierarchy and simply explain how to install and use it.

Linux System Hierarchy

Linux is an operating system kernel with a Unix-like design. The kernel is designed by Linus Torvalds and is still developing it as open source. The latest kernel version is Linux 5.14. and available at the link. Linus Torvalds also owns the git project, a source code management and version control software. Named in 1991, this monolithic kernel is widely used in operating systems used by supercomputers, personal or mobile devices. For example, Android, Debian, RHEL(Red Hat Enterprise Linux), CentOS are examples of GNU/Linux distributions. Especially Debian and Debian-based distributions, RHEL and RHEL-based distributions are frequently used as server operating systems.
Linux and Unix are monolithic kernels. Monolithic kernels occupy a larger area than microkernels. Essentially, operating systems using Monolithic kernels run all operating system functions in "kernel mode", that is, kernel space. Each process is in separate address spaces. Kernel and OS services are in the same address space. Processes can request service from the kernel. This creates a layer of security between the kernel and applications. It also provides high speed as there will be no message traffic. However, a change to the kernel requires recompilation and the kernel code can become quite complex. In systems using microkernel, "kernel mode" takes up less space. System services such as the file system, virtual memory manager, and CPU scheduler are in the "user mode" area on the kernel, and each has its own address space. Applications also have their own address space. Such cores are customizable and easily expandable. In Microkernel, a fault in a component does not affect the whole system thanks to the system architecture. In this respect, we can describe this architecture as durable. However, in case of an error in monolithic systems, the whole system will be affected because the services are interconnected. But it has a clear advantage over monolithic architecture in terms of speed. Examples of microkernels are symbian, minix, GNU. Most Linux distributions are not actually a Linux project, but rather a GNU project. Because linux is just a kernel and it makes up a very small part of the whole system. Hybrid architectures, on the other hand, are a combination of the good features of monolithic and microkernels, thereby reducing weaknesses. They keep more code in the kernel space. Communication units and many drivers are embedded in the kernel area. However, when a new component is added, it does not require recompilation as in monolithic architecture. For example, Darwin and macos kernel XNU, BSD-based freeBSD, windows NT are coded in this architecture. Modern operating systems prefer this architecture.

source : wikipedia

Init System

It is the ancestor process on a GNU/Linux system. It takes 1 as pid and after the kernel is loaded, it is decided which runlevel the system will start with by checking the runlevels in /etc/inittab in modes such as windows or safemod that we are used to from macos. Runlevels can be seen in the figure below. As seen in the inittab file in Centos7 system, 0 halt, 1 single usermode, 2 multiuser etc. is being used. 3, ie Full multiuser mode, is used by default as initdefault. After init is started, other processes are started in the appropriate order and in the mode used under /etc/rc.d/init.d. For example, udev , apache, preload services can be started after init. This is used like /etc/rc.d/init.d/init3.d/S100preload. init3.d is in 3rd mode and S100 indicates that preload will be started in 100th order.

This structure is not preferred in today's GNU/Linux distributions. In most of them, systemd, which was written in 2010, comes by default. It is also used in new generation structures such as runit, OpenRC, Upstart. The old build is the SysV init system. In new structures, there are features such as starting processes in parallel, automatically starting the process that a process needs, automatic restarting if the process terminates. Systemd is a slightly slower init system than others. The system with the fastest boot time among them is Runit and it is cross platform. Available on GNU/linux, Solaris, Macos X.

File System and Directory Hiearchy

The file system is a markup structure on the disk that allows the operating system to find the file. GNU/Linux distributions usually use ext2–3–4 journaling systems. It can also find file traces on NTFS, the windows file system. Everything is a file and designed in a hierarchical order in directories. Files, drivers, executables, libraries are located in these directories. This directory structure can be seen in the figure below.

In normal use, we can say that the most used directories are /var, /lib, /usr and /home. In addition, directories branch themselves into trees. For example, the /usr directory contains the /usr/bin directory with binary files. Or the directory /var/lib is available under /var. /bin directory is loaded at boot and contains basic commands. /sbin contains binary files that provide system information or make changes. /lib contains shared libraries, /media contains removable disks, /mnt contains new mounted filesystem, /var contains variables. The /home directory contains users' private files. /etc contains configuration files. The /boot directory contains the bootloader and some core files, such as grub, lilo, related to system boot. These directories can be divided into different partitions and connected to the system. This is a widely used method. For example, when the home directory is installed on a partition separate from root, the programs installed in the users' files and user directory are not deleted when the system is reinstalled or a different GNU/Linux distribution is installed. Bedrock Linux designers have developed a different model on this hierarchy.

Bedrock Linux

Bedrock Linux is a productivity-oriented daemon that aims to use modules from many distributions, defined as a meta-distribution, together in a single operating system. In other words, you can work on debian and use pacman or AUR package managers and packages from arch linux. You can use libraries in different operating systems and fonts installed in different systems for different programming. This system also has some bugs. It is currently progressing above 0.7 poki minor. In addition, it cannot be said that it is security-oriented. This system is very useful for users who want to benefit from the power of not only a single system, but also many systems, and who want to use more than one package manager, different packages or different init systems at the same time. You can check it from the link.

The system is very simple to use. Once the Strata concept is well understood, it is quite easy to adapt for an advanced user. After a shell script is downloaded from Github, it is started as root and you will be asked to confirm the action you want to do, as a warning that the actions cannot be reversed. It then takes the distribution in your root directory and moves it to a stata under /bedrock. You can integrate other distributions into your system with the brl command. You can also configure your system in bedrock.conf file. It is located under /etc/becrock. brl apply is used to apply the changes. Community side usage rates are given on the official page of Bedrock linux (link). Generally, you have a low error rate for frequently used distributions. For example debian,ubuntu,centos,arch are used quite often and there are no known problems. But many problems have been reported in different distributions such as clear linux, nixOS. The concept of Strata will be discussed in the next section.

Strata

Bedrock installs each distribution on one layer, establishing a communication bridge between them and providing the appropriate environment for other inter-use.

$ brl fetch --list

With the command, distributions that can be used as stratum can be seen.

$ brl fetch void

With this command void linux startum can be created. It has the void linux runit init system. When Bedrock init interface comes, you can see it as void:runit.

$ strat -r debian neofetch

When the command is used, the neofetch package in debian stratum will run and see debian as the root directory. It outputs debian as os-release. But when neofetch is used directly, bedrock linux will be seen as os-release. Occurs when build tools scan the environment and find dependencies from different distributions. In case of confusion due to the bedrock environment like this, inter layer hooks can be bypassed using the restrick -r parameter. If you are using two distributions with the same package manager, for example apt and rpm are the most used package managers, then you can start ubuntu as apt. Such an application may be needed because the source repos are different.

If a package exists in more than one startum then it will be executed in “pinned” stratum. You can check this with brl which . All layers can see /run , /temp , /home directories as global file path.

You can enable-disable some stratums if needed. You can use the brl enable/disable command. You can use the brl remove -d command to delete Stratum directly.

$ brl remove -d fedora

Installation, Use and Review

In this section, some topics such as how to create and configure some startums by installing bedrock on ubuntu-based virtual linux lite in virtualbox, how to install package software will be explained. You can choose in a different distribution. In particular, distributions that have not undergone major changes based on common or frequently used distributions can run smoothly. For installation, you can download the script suitable for the CPU architecture from the link. First of all, daemon installation should be done by running bedrock shell script as root user.

“Not reversable!” By typing you agree to these terms and installation begins. Before the installation, the os in the root is taken to a temporary location. Then bedrock is installed on root and the os in the temporary location is installed in a layer. After the process is finished, you can see the init selection textmode interface with reboot.

Here, the system is booted from the system marked with "*". /sbin/init points to /usr/lib/systemd/systemd here. Systemd services are started and system boot is provided. When ubuntu is booted, processes named crossfs and etcfs are file systems for moving files, libraries, fonts between layer boundaries. In addition, the paths containing the stratum binary files are added to the PATH variable. This way bash or any shell

I am installing the neofetch package on Ubuntu. You can install it from the ubuntu apt repos. Then, when I use the neofetch command, the base system appears as bedrock. To run neofetch in Ubuntu startum.

$ strat -r ubuntu neofetch

command should be used. With restrict cross-startum hooks are disabled. This way neofetch will only work in ubuntu stratum.

To create another startum,

$ brl fetch --list 
alpine
arch
...
...
$ brl fecth void

You can check the distros out with the command. Then it is downloaded and installed from stratum mirror with brl fetch. For example, for void linux using runit, after the packages are pulled, void can be seen in the init menu. When strat -r void neofect is run again, it will warn that the package is not present. Because there are no hooks in between, it cannot reach the neofetch package in ubuntu startum. In this stratum, the package is installed and run with sudo xbps-install neofetch.

There are both ubuntu and void startums in the system. Here the xbps package manager and apt package manager can be used jointly. E.g

$ sudo xbps-install filezilla

via this command , Filezilla can be installed and run in ubuntu stratum. The opposite is also true. For example, in Arch linux startum, you can install a package from AUR packages and access it from other startums. For this, git can be installed with pacman and the spring helper software can be installed from the github repo. With yay -Sy brave a package belonging to arch stratum can be used by all stratums.

In the next system startup, there are three options for init selection. Besides arch and ubuntu using systemd, void linux uninit system using runit can be used.

System-related settings can be made in the bedrock.conf file. For example, the default init can be changed, the timeout period can be shortened, the directory where the fonts are located or the priority settings between the stratums can be made. Mirror servers can be changed for "brl fetch". For detailed information, you can use this link.

This system is completely productivity-oriented. There may be some security related problems.The official page has some answers for those who have security concerns.
However, if security is at the forefront for you and the features of multiple distributions are desired to be used together, it is more appropriate to use distributions such as Qubes.Qubes virtualizes each OS to the next level. It is a system that aims to provide security through isolation. It recommends Whonix by default, but you can also install windows or fedora, debian. Safety and productivity/speed are two conflicting concepts here. I think this distro is a meta distro to be used by distro-hoopers after major 1.0.0 release. Even this version is free from many problems and lives a very stable user experience.

mono-.net core integration on Monodevelop

nuh yurduseven — Sat, 22 Aug 2020 21:39:42 +0000

Hi, I am the new member of the team and this post is my first. Ok. for a long time I try to install-integrate mono-.net core on monodevelop IDE. I am using Solus and perhaps that's why I got hard. I don't know "how to do this work on other distro". But I have decide share with you this experiences. Bugs, errors etc.

If you want to create a .net core app and build this app, you can use mono framework. I try a .net core 2.1 LTS and mono 6.8.0.105 on runtime.

Make it happen installation monodevelop, mono framework and dependency packages .netcore-2.1 LTS sdk on your system. Then;

for .netcore sdk:
open /etc/profile and add Path variable

PATH=$PATH:/your/dotnet/sdk/path and DOTNET_ROOT=/your/dotnet/sdk/path

and do:
$ source /etc/profile

Ok. You have a dotnet command reachable everywhere anymore.

you can try:
$ dotnet --version

Thus, after created new solution, you can go into the project directory and run dotnet build command.

Open the monodevelop IDE and go Edit->Preferences->Sdk Location->.Net core and add dotnet core command line.

then create a new solution ASP.NET core web API or app. Right click project app and select options. You should check target framework inside General tab.

Under the Run tab right side of General tab there is a ASP.NET core tab. You can change port here In general tab, do not select "Run on external console". This option(form of 'unclicked') provide to use application console in monodevelop.

Build app.

I could not run .netcore 3.0 sdk LTS with this release of mono. Perhaps It should was installed latest mono framework.

As a result, an asp.net core app or API can be developed via mono on Monodevelop IDE for both Linux and Mac. This method can be used for this.