Bitácora en cápsulas.

test octopi

2025-09-01T07:44:00.009-04:00

dd if=/home/j3nnn1/octopi/octopi-1.1.0-1.11.2-20250610114348.img of=/dev/mmcblk0p1

dd if=/dev/source of=/dev/destination bs=4M status=progress

dd if=/home/j3nnn1/octopi/octopi-1.1.0-1.11.2-20250610114348.img of=/dev/sdb bs=4M status=progress

pi@octopi:~ $ cat /boot/firmware/wifi.nmconnection

[wifi]
mode=infrastructure
ssid=ddddd

[wifi-security]
auth-alg=open
key-mgmt=wpa-psk
psk=ddddd

sudo systemctl restart wpa_supplicant

sudo journalctl -u wpa_supplicant

el archivo octopi-wpa_supplicant.txt no me funca. Nunca lo copia.

Configurar WIFI despues del reinicio el modem y pierdas la IP statica.

sudo nmtui

nmcli device show wlan0

sudo raspi-config no funciona muy bien, al no poder ver o hacer debug de los errores de las apps internas que usa.

Pasaron casi dos años desde mi ultimo post

2023-04-27T16:49:00.001-04:00

Despues del post parto la vida personal se vuelve un caos, y luego la vida laboral volver al ritmo de no tener molestias fisicas y todo el tema psicologico hizo un poco dificil continuar publicando con frecuencia mensual por acå, asi sea de mis anotaciones y no quiere decir que deje la parte tecnica sino mas bien, limpiar ,formatear y dejar algo entendible para mi yo del futuro estaba muy dificil y en el orden de prioridad de ultimo.

Hoy retomando con esta peque intro de llanto de alegria, y justificaciones, parte de mi aceptacion dejo unas anotaciones de airflow que ultimamente estoy usando mucho.

Desde entonces (2021) hice una diplomatura de deep learning y este año me anote en otra de big data. Me gusta desarrollar/ programar asi que no creo que deje de hacerlo asi mi job post title diga que ahora estoy como data engineer.

Esta imagen la saque de stack overflow como todo skill de saber googlear. es importante. y bueno dejo las referencias:

Un abrazo calido, que esten bien.

go tools

2021-12-15T15:33:00.001-04:00

As developer we constantly use tools that let us go faster in our daily tasks, not only go faster also we have to write code with a good quality, because we need to write thinking in the next developer that will have to touch the code, so always choose explicit instead implicit, keep the things simple and Try to not repeat yourself (DRY). In this long way we always continue learning and improving our way of writing code in Go language, some of this tools I listed here:

go get / go install (Go tools)

This cli command lets you get a dependency and install it in your GO_PATH. In the last version of go (1.17.0), “go get/install” was redesigned with modules, and improved usability of it, which will help speed up the process of getting users up to speed.[2]

With go get your will update your dependency and edit go.mod and go.sum. In the best practice of golang they advise to generally not try to consume or edit go.mod and go.sum directly because this should be timeless for the foreseeable future, also it's hard for a human to fully understand the dependency graph by reading a go.mod file. Also with go get you could remove dependencies, the command looks like “go get example.com/theirmodule@none”[2]

Using go tools to get your dependencies your requirements remain consistent and the content of your go.mod file is valid. If you need to search for packages you might find useful, you should query here: https://pkg.go.dev/

“Go mod init “ lets you initialize a new module, and when you are using conventions this ensures it’s available to others via Go tools. Each directory is considered its own package, and each file has its own package declaration line. One repository could have one module or multiple modules (decentralized publishing), the best practice is to have one module by repository because it’s better for upgrade, and maintenance is simpler.[1]

A module could have many packages inside. When Go sees that a package is named main it knows the package should be considered a binary, and should be compiled into an executable file, instead of a library designed to be used in another program. When Go sees a function named main inside a package named main, it knows the main function is the first function it should run. This is known as a program’s entry point. GOPATH is an environment variable where you define where the go binary is. Don't worry if you are not familiar with the GOPATH, because using modules replaces its usage.[3]

“go list -m all” list all dependencies(-m = modules ) with -u list the modules that need an upgrade and “go list -m -versions github.com/lib/pq” list all versions for the lib/pq module. “go mod tidy”: is used for removing unnecessary or unused dependencies.“go install”, let you install the application locally.

GVM (go version manager) [5]

require bison package at least, to install this: sudo apt-get install bison or sudo pacman -S bison

The easiest way of install this tools, is with the script installer, you could use bash or zsh:

bash < <(curl -s -S -L https://raw.githubusercontent.com/moovweb/gvm/master/binscripts/gvm-installer)

The output should looks like: Cloning from https://github.com/moovweb/gvm.git to /home/jennifer/.gvm
Created profile for existing install of Go at /usr/local/go
Installed GVM v1.0.22
Please restart your terminal session or to get started right away run
`source /home/jennifer/.gvm/scripts/gvm`

Gvm commands:

➜ ~ gvm list all # to list all go version on my laptop

➜ ~ gvm install go1.14.1 # to install a new go version

➜ ~ gvm use go1.17.4 # to use a go version in the current terminal session

➜ ~ cd new_project #to use many gopath directories, new_project will be added to GO_PATH
➜ ~ gvm pkgset create -local
➜ ~ gvm pkgset use --local

Ayu [6]

Ayu is an extension for visual studio code IDE, this extension implements three themes: Ayu Dark, Ayu Light and Ayu Mirage, this themes lets you highlight the go syntax, as I spent long hours with IDE on my screen it’s comfortable to my eyes to have set Ayu Mirage as theme.

Golines

Golines is a go app that lets you short the length of lines in a file or in all the files in a directory. To install: go install github.com/segmentio/golines@latest and to use: golines [paths to format] you could configure this command in visual studio code to be executed every time you save the file (Run on Save plugin [7]).

Go test and Go mock

Is part of the Go language core so you do not need to define your own interface and mock classes. You do not need to depend on a third party library. The creators of Go foresaw the need to mock outbound HTTP requests a long time ago, and included an API in the standard library. The API is provided in the package httptest, and there are many examples of how to use it, including not only in the httptest package’s own Godoc example. Unit tests are useful for the maintenance of code and checking if the application it’s ok after we upgrade our dependencies, and let us make sure our packages and modules are working correctly. “go test all” runs the tests of all direct and indirect dependencies of your module, which is one way to validate that your current combination of versions work together[8][9]. If you are curious as to why a particular module is showing up in your go.mod, you can run “go mod why -m <module>” to answer that question. Other useful tools for inspecting requirements and versions include “go mod graph”.

Some recommendations: when you have to update an API in a golang module you should create a new path for the new version in case the contract API is modified in some parameters. Choose to use interfaces to make a contract for Request and Response API’s, reserve time to do unit tests, and functional tests with a coverage over 70%, use “go test -v -cover” to check this[10]. With these tools and taking into account these recommendations we built better software, that will keep back compatibility with older versions, and make for the next developers an easy task or more comfortable the maintenance of the project.

[1] https://go.dev/doc/modules/managing-source

[2] https://go.dev/doc/modules/managing-dependencies

[3] https://go.dev/doc/modules/developing#workflow

[4] https://go.dev/blog/module-compatibility

[5] https://github.com/moovweb/gvm

[6] https://github.com/ayu-theme/vscode-ayu

[7] https://marketplace.visualstudio.com/items?itemName=emeraldwalk.RunOnSave

[8] https://github.com/golang/go/wiki/Modules#faqs--gomod-and-gosum

[9] https://github.com/golang/go/wiki/Modules#how-to-upgrade-and-downgrade-dependencies

[10] https://gitlab.intraway.com/jennifer.maldonado/gpon-ipv4-simulator-config/tree/master/dhcp_templates

PD: sorry if there are any typos or grammar mistakes. Suggestions for corrections are accepted.

avoiding CORS ups..

2021-12-14T16:24:00.003-04:00

bad practices

How to avoid CORS error on google-chrome-stable version >= 96.0.4664.93

1 - execute google chrome by cli in this way:

google-chrome --disable-web-security --user-data-dir=/tmp

2 - access to this URL in the new chrome opened: chrome://flags/#reduced-referrer-granularity

and disable web security.

search by:

Block insecure private network requests.

Prevents non-secure contexts from making sub-resource requests to more-private IP addresses. An IP address IP1 is more private than IP2 if 1) IP1 is localhost and IP2 is not, or 2) IP1 is private and IP2 is public. This is a first step towards full enforcement of CORS-RFC1918: https://wicg.github.io/cors-rfc1918 – Mac, Windows, Linux, Chrome OS, Android

See Also:

- https://developers.google.com/web/updates/2020/07/referrer-policy-new-chrome-default

- https://chromestatus.com/feature/6251880185331712

git-worktree

2021-11-28T13:06:00.003-04:00

Since 2015 git added a command git-worktree. This command could be used when you have a repository and each branch represent an old Versions of the code, one feature_branch or simple using the main branch. This command generate a new tree, and you can avoid doing checkout on branches every time you have to do an urgent bug fix or edit without doing changes on the main tree locally.

Advantages.

the Time spent by you IDE to reindex the switched branch, so you save a little of Time If you use some jetbrains IDE or eclipse.
No need to fetch ,if you don't want to.
By each tree you Will have a new project in the IDE .
This command use a new directory un your file system, AND use the same .git/config file.
You could compare the code by tree, branches, and directories.

In the old fashion way you Will have to clone each repo in diferents directories, and check or set manually same config on .git/config, each directory Will be a project in you IDE. In this way you only could compare by directory and by branch.

Another way was use git stash to save what are you working on, and do the checkout to the branch version with the bug on production, this way you have a Lot of context switch (to make an hotfix) , cos you Will need to do the reindex on you IDE (in case you use eclipse or some jetbrains IDE ), and later checkout to your branch_feature, unstash, AND again reindex, and always don't forget to clean cache!

Some examples:

(base) ┌─[j3nnn1@caracas] - [~/git/tools] - [Sun Nov 28, 13:26]
└─[$] <git:(master)> git worktree add /home/j3nnn1/git/tools2
Preparing worktree (new branch 'tools2')
Updating files: 100% (2887/2887), done.
HEAD is now at db7534a Update paquetes.txt

When hotfix is ready and the fix it’s in production:

└─[$] <git:(master)> git worktree remove /home/j3nnn1/git/tools2

$ git worktree add <path> <branch>

With -d throwaway working tree

git worktree prune

To clean up any stale administrative files.

git worktree lock

To not delete, remove, or prune when gc.worktreePruneExpire passes.

List all trees

└─[$] <git:(master)> git worktree list
/home/j3nnn1/git/tools db7534a [master]
/home/j3nnn1/git/tools2 db7534a [tools2]

chezmoi saving your config files versioned

2021-11-25T13:15:00.005-04:00

pacman -Syu chezmoi

chezmoi init (make a new dir ~/.local/share/chezmoi)

chezmoi add ~/.bashrc

chezmoi [add|edit|update] ~/.bashrc

chezmoi cd (~/.local/share/chezmoi)

git remote add origin https://github.com/j3nnn1/dotfiles.git

git branch -M main

git push -u origin main

Additional config:

git config pull.ff true

git config pull.rebase true

and that's all.

udev events, making an udev rule and debugging rules.

2021-11-21T22:26:00.004-04:00

udev is a device manager for the linux kernel.

when you connect some device (pendrive, camera, microphone) on a linux machine, you have a daemon listen to events that are fired when the kernel register a new device. All devices are mapped to a file on /dev so you could check some info about the device with this command:

udevadm info -a -n /dev/DEVICE_NAME

i.e.: udevadm info -a -n /dev/ttyUSB2

udevadm info -a -n /dev/ttyUSB2 | grep '{devpath}' | head -n 1
udevadm info -a -n /dev/ttyUSB2 | grep '{idVendor}' | head -n 1
udevadm info -a -n /dev/ttyUSB2 | grep '{idProduct}' | head -n 1
udevadm info -a -n /dev/ttyUSB2 | grep '{serial}' | head -n 1

knowing the device info we could make a rule based in the information and execute a new action: make a file, make a symlink or execute a script. For example I want to create a rule that match with the attributes devpath, idVendor, idProduct, serial and generate a new symlink.

we need to create a file into:

/etc/udev/rules.d/99-some-rule.rules

- in this file we need to use "" in the values.
- each line is a rule.
- each line has many or one attribute and one action. When the attributes matched the action is executed, that's all.
- if you edit or create a new rule, you need to load and trigger all rules again.

udevadm control --reload-rules && udevadm trigger

- so sometimes is tricky check why some rule is not executed. For debug you have:

    - udevadm test /devices/platform/soc/3f980000.usb/usb1/1-1/1-1.3/1-1.3:1.0/ttyUSB0/tty/ttyUSB0

      the devices path you could obtain with the comand udevadm info.

    - udevadm monitor

      show the events that are fired.

    - udevadm control --log-priority=debug

      set the environment on debug mode.

    - udevadm test $(udevadm info --query=path --name=ttyUSB0)

      test all rules associated to the device name ttyUSB0

- when you have an syntax error on some rules file, this will appear in the logs:
    - journalctl -f

- restart service:
    - systemctl restart systemd-udevd

- kernel messages
- dmesg

- example: file called 99-new-rule.rules:

SUBSYSTEM=="tty", ATTRS{idVendor}=="1a86", ATTRS{idProduct}=="7523", ATTRS{devpath}=="1.2", ATTRS{bcdDevice}=="0264", SYMLINK+="FANCY_NAME"

The 99 number indicated the priority for execution. in this case would be the last one to execute.

It's important to put double quotes instead single quote.

Using Cloud Native Buildpacks and paketo to improve software as service.

2021-10-29T08:31:00.006-04:00

In a changing world technology is constantly evolving, so it is necessary to take action to stay tuned about it and bring the best solution to our customers. Every day are found security issues on the operative system[11] and are necessary to do patches, path to libraries, and so on. For this it is necessary to update app images in an easy, standard, performantly, and secure way, because containers are industry standard today.

It is a very common task in development that we have to create a docker image from a source code, and more usual is that the image needs to be ready for a cloud environment. In this case we don't have a specific way to do it, there is no standard, but exists best practices to generate a app images from our source code:

- [Small size image] You need an image with a small size.

- [Multistage] You need to generate the images in two stages or more depending on the language, for example in Go you need a first stage to get all things needed by the app (dependencies, compiler, external libraries) and later when you compiled the source code to later you could copy that binary to a minimized image. (Could be an alpine image with a small size).

- [Reduce Layers] You need to do an Optimize dockerfile, for example take into account how to build the layer to make it more performante[1]. Always we need to reduce the number of layers, design ephemeral containers, avoid storing application data and any other building tools that we don’t need to run or execute the application.

Besides having tools like Docker Linter https://hadolint.github.io/hadolint/ often we spent a lot of time doing the image and refactoring dockerfile to reach a small image size, with the best practices, and more efficient. This need was detected by the pivotal1 and heroku2 approximately in the year 2011 as a result of all the complexity that can be had to set up images without having standards or guidelines. They defined Buildpack3 this concept of buildpacks was broadly adopted by CloudFoundry, Google App Engine, GitLab, Knative, Deis, and more.

Buildpacks from pivotal and Buildpacks from heroku are slightly different, so in 2018 both companies join force to present to the cnfc (Cloud native computing foundation)4 a project based on Buildpacks but not the same.

Once that cnfc approved this project, they created buildpack.io as a standard[5] and coined it “Cloud Native buildpacks”, to unify the buildpack ecosystems from pivotal y heroku and a higher level abstraction for building container images. In the same year Using the knowledge of the many years of experience with buildpacks, the CloudFoundry buildpack engineering team created the Paketo.io project which is based on former CloudFoundry Buildpacks (CNB).

So what are Buildpack / Cloud Native Buildpack? is a kind of app, tool or open source scripts that transforms your application source code into an image, and the image container is more secure. Buildpacks (CNB) ensure apps meet security and compliance requirements by CNCF, perform upgrades with minimal effort and intervention.

Inclusive with less network data transfer because this does the update by layer or stacks. Cloud Native Buildpacks embrace modern container standards, such as the OCI image format and they take advantage of the latest capabilities of these standards, such as cross-repository blob mounting and image layer "rebasing" on Docker API v2 registries[7].

“rebasable” images or image layer “rebasing” is related to ABI compatibility[6] It is the contract provided by OS vendors that guarantees that software doesn’t need to be rebuilt when security patches are applied to the OS layers. It makes “rebasable” image layers safe to rebase. So let you update the Os layer without a risk of sort incompatibility to crash your app.

On the other hand, Is very easy to use when the code is in a good shape or has a good smell. But when it is not, you’ll need to do a refactor of your code. The best way to use Buildpack is with pack:

There are many form of install pack[8] the one that I used was by command line or the tab with the script install where you only need to execute this line with sudo or a user with grant to write on /usr/local/bin and that’s it:

(curl -sSL "https://github.com/buildpacks/pack/releases/download/v0.15.1/pack-v0.15.1-linux.tgz" | sudo tar -C /usr/local/bin/ --no-same-owner -xzv pack)

To use pack we should have docker installed in our machine, basically pack autodetect what kind of image we need to build looking into the code, based on that pack choose a builder which is an image that bundles all the bits and information on how to build your apps, such as buildpacks, an implementation of the lifecycle[9](a kind of implementation of Cloud Native Buildpacks specs from CNCF) it's still in beta. In summary you have to download or write the code, change directory to the app directory or root path.

# clone the repo
git clone https://github.com/buildpacks/samples

# go to the app directory
cd samples/apps/java-maven

You could also see in samples/buildpacks/java-maven how is writed the definition or specification (CNB10) with a toml extension file, and how will be apply to choose the right builder, in the directory stack we could see some Dockerfiles with the instructions or recipe with the tools to build an image, every stack has a Dockerfile definition.

And execute the next line:

# build the app
pack build myapp --builder cnbs/sample-builder:bionic

And that’s it, you’ll be using Buildpacks. The buildpacks (CNB[10]) specification and the file structure could be a little complex when the project grows up. You could have Buildpacks inside another Buildpacks definition, long buildpacks files, a lot of toml files in a hierarchical way and a lot Dockerfiles, so in the same time Vmware (Pivotal and CloudFoundry) made paketo where Paketo slogan is Let's Pack, Push and Deploy!

Paketo is a new way to build buildpacks, redefine the relations between the components in a modular way, using composition in dependencies where each element has a single responsibility. This make Buildpacks easy to maintain and to do contribution, on others words is like a refactor from cloudfoundry buildpacks to avoid monolithic buildpacks and Dockerfiles:

written using different programming languages, for different purposes.

Paketo uses a base image called tiny which is effectively distroless and provides a method to more rapidly deploy application code in a way that eliminates the need to create customizations for each deployment platform. This eliminates the need for the container community to reinvent many times the same wheels over again. The separation of concerns they provide, makes the developer’s life easier as they can focus more in the application and product development.

Paketo Buildpacks needs docker and pack installed, the community has done a lot of samples to give it a try ( https://github.com/paketo-buildpacks/samples) and they encourage you to contribute to it. Paketo Buildpacks could be the next generation or an evolution from docker (Dockerfiles) and let us focus on the business problems we’d like to solve. Let's Pack, Push and Deploy!

Referencias.

[1] https://run.pivotal.io/

[2] https://www.heroku.com/

[3] https://buildpacks.io/

[4] https://www.cncf.io/

[5] https://github.com/buildpacks/spec/blob/main/buildpack.md

[6] https://en.wikipedia.org/wiki/Application_binary_interface

[7] https://buildpacks.io/docs/app-journey/

[8] https://buildpacks.io/docs/tools/pack/

[9] https://github.com/buildpacks/lifecycle/releases

[10] Cloud native buildpacks

[11] https://www.researchgate.net/publication/315468931_A_Study_of_Security_Vulnerabilities_on_Docker_Hub

[12] https://blog.codecentric.de/en/2020/11/buildpacks-spring-boot/

[13] https://paketo.io/docs/

Sorry for any grammatical or spelling mistakes

hugs

j3nnn1 (:

https://kubevela.io/ and https://github.com/oam-dev/spec last 2021 was elected as sandbox project from cncf. kubevela keep focus on application approach instead of the implementation. oam is the specification or standard.

4 tools in javascript

2021-09-06T12:18:00.007-04:00

picture name: wichy asking for more coffee

01 NVM:

NVM is the acronym for Node Version Manager, which is a command-line tool that lets you install and use many Node.js versions and NPM on your computer. It is a dev tool, so I don't recommend using it in production environments. NVM works fine in Linux and Mac. You can also check the documentation here: https://github.com/nvm-sh/nvm.

When is it useful to use NVM?

* In teams where we have different operating systems.

* When we have to test new things, for example, the testing version for Node.js.

* When we have many projects with different versions, and you cannot update Node.js and you have to maintain two or more node js versions in many projects, so is a way to tidy up the dev environment, switching between Node.js versions.

NVM: Installation

Mac:

You can use homebrew. If you don’t know how to install it, you could check here it (https://brew.sh/) and that’s all.

brew install nvm
source $(brew --prefix nvm)/nvm.sh
echo 'source $(brew --prefix nvm)/nvm.sh' >> ~/.profile

Linux:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.34.0/install.sh | bash

The line before will have an output such as this:

=> Downloading nvm from git to '/home/jennifer/.nvm'
=> Cloning into '/home/jennifer/.nvm'...
remote: Enumerating objects: 278, done.
remote: Counting objects: 100% (278/278), done.
remote: Compressing objects: 100% (249/249), done.
remote: Total 278 (delta 33), reused 88 (delta 16), pack-reused 0
Receiving objects: 100% (278/278), 142.36 KiB | 0 bytes/s, done.
Resolving deltas: 100% (33/33), done.
Checking connectivity... done.
=> Compressing and cleaning up git repository
=> Appending nvm source string to /home/jennifer/.bashrc
=> Appending bash_completion source string to /home/jennifer/.bashrc
=> Close and reopen your terminal to start using nvm or run the following to use it now:
export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" # This loads nvm
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion" # This loads nvm bash_completion

Make sure that these lines below are in your ~/.bashrc or ~/.zshrc:

export NVM_DIR="$([ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm")"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" # This loads nvm

My personal desktop runs over Arch Linux, so I used an aur package, for example https://aur.archlinux.org/packages/nvm/. I downloaded the snapshot file and uncompressed the tar.gz file. Also, you could use the same installation explained before or these lines for installing nvm:

$ cd nvm
$ makepkg -s #this will generate an Arch Linux package (nvm.tar.xz).
$ ls -l nvm.tar.xz

$ pacman -U nvm.tar.xz

NVM Usage:

nvm list : List all versions installed on your machine

➜ ~ nvm list
-> system
iojs -> N/A (default)
node -> stable (-> N/A) (default)
unstable -> N/A (default)

NVM install: Install a local version on your machine from the remote list. The remote list could be filtered by another command like: nvm ls-remote <versionLike> for example “nvm ls-remote v11” lists all versions that have v11 as prefix.

➜ ~ nvm install v10.15.3
Downloading and installing node v10.15.3...
Downloading https://nodejs.org/dist/v10.15.3/node-v10.15.3-linux-x64.tar.xz...
######################################################################## 100,0%
Computing checksum with sha256sum
Checksums matched!
Now using node v10.15.3 (npm v6.4.1)
Creating default alias: default -> v10.15.3

nvm use: set in the current terminal the environments variables so all command executed related to Node.js will use the version defined by NVM.

➜ ~ nvm use v10.15.3
Now using node v10.15.3 (npm v6.4.1)

nvm which: show the path to the Node.js bin file.

➜ ~ nvm which v10.15.3
/home/jennifer/.nvm/versions/node/v10.15.3/bin/node

02 Docker container with node js/ angular-cli:

Hub docker contains a thousand images that you could use in your daily tasks at work, in a simple search you could see (https://hub.docker.com/search?q=angular-cli&type=image)

About 1 - 25 of 492 results for angular-cli.

Here is my recommendation to use it in a local environment for a development process: https://hub.docker.com/r/trion/ng-cli/

docker pull trion/ng-cli

When node_modules directory already was generated.

docker run -u $(id -u) --rm -p 4200:4200 -v "$PWD":/app trion/ng-cli ng serve --host 0.0.0.0 --disableHostCheck

In this way, you need node_modules directory inside the directory defined in $PWD variable.

When a node_modules directory is not generated. And that’s all.

first

docker run -u $(id -u) --rm -p 4200:4200 -v "$PWD":/app trion/ng-cli npm install

later:

docker run -u $(id -u) --rm -p 4200:4200 -v "$PWD":/app trion/ng-cli ng serve --host 0.0.0.0 --disableHostCheck

03 Dotenv using a .env file with and avoid versioning

Dotenv is useful to keep tidy up the code, avoid magic number, avoid push any secret key to the repo and it is a relief for many environments. With this, you can run your app anywhere by modifying the environment variables without changing your code and without rebuilding it!

npm install dotenv

Later, create the .env file in the root of your app and add your variables and values to it. Don’t forget to add this file to .gitignore to avoid committing it.

.env
PORT=55555

Server.js
const dotenv = require('dotenv');
dotenv.config();
console.log(`Your port is ${process.env.PORT}`);

4 Cloud solutions:

For each project, you could use one of these, sometimes I have to share code with a friend or when I have a doubt, and I need to ask something with a context code, it’s the best way to show when you are remote, for example for an angular-cli project there is no doubt that the best is https://stackblitz.com/ has a better integration with angular and let you download the project in a zip file, also is recommended by @angular documentation.

Also for Js, HTML, and CSS, and tiny projects you could use https://jsfiddle.net/, https://codepen.io/. In the last one, there are many web artists and you could make you own portfolio to share it. And From Red Hat, we have https://codenvy.com/ has a free subscription with limitations, but it’s ok for prototyping things.

Reinstalling Archlinux on a old Laptop

2021-08-19T12:08:00.008-04:00

Yesterday I accidentally run rm -rf / because everybody makes mistakes.

each step is written here:

1 - first memtest86

2 - swap memories, test one memory slot each time, and test a new one memory module from another laptop that it's working. So in this part I figure out that my laptop was broken, so Nico borrow me an old laptop :'-( .

3 - UEFI, installing Archlinux on UEFI require use the pen-drive on UEFI mode. after boot on UEFI mode, I did a back up to the files on the /home directory and install the Operative System again.

4 - first I already have the partition so, this part is not new. the only thing with this new laptop is that I have to do a new UEFI partition to the grub, my old laptop does not have UEFI mode, so the grub was installed in the BIOS MBR sort of.

After I did the new UEFI Archlinux partition with "cfdisk /dev/sda" change Type to UEFI system, and verify if the notebook has a the boot mode UEFI listing this directory:

ls -l /sys/firmware/efi/efivars

If the output show you a list of files! Bingo you are currently booting in UEFI mode.

In UEFI we need the partition table in this Disklabel "GPT", so we check with

fdisk -l if the partition table is type BIOS or GPT. the output should be like:

"Disklabel type: gpt"

Also used parted -l to fix an error that was show up when we execute "fdisk -l":

"something that GPT partition was different from MBR partition"

"GPT PMBR size mismatch" something like that.

To do that: I installed parted

$pacman -S parted && parted -l /dev/sda

5 - After that I formatted the partitions to do a fresh installation.

mkswap /dev/sda6

swapon /dev/sda6

mkfs.ext4 /dev/sda5 => /root

mkfs.vfat -F32 /dev/sda7 => /boot/grub/efi

6 - preparing for the chroot

from general to specify

mount /dev/sda5 /mnt

mkdir -p /mnt/boot/efi

mount /dev/sda7 /mnt/boot/efi

7 - using pacstrap to install base system

pacstrap /mnt base base-devel grub os-prober ntfs-3g networkmanager efibootmgr gvfs gvfs-afc dhcpcd vim linux-headers linux-firmware linux netctl wpa_supplicant xf86-input-synaptics pavucontrol htop lshw meld transmission-gtk docker docker-compose gvfs-mtp xdg-user-dirs lightdm xorg xorg-xinit gnome-keyring xorg-server xorg-server-common xf86-video-vesa xorg-font-util ttf-dejavu opencl-nvidia dkms git terminator rsync go-tools cinnamon-desktop cinnamon gnome-terminal lightdm-gtk-greeter pulseaudio pulseaudio-alsa firefox vlc gimp xfburn gedit gnome-system-monitor faenza-icon-theme smartmontools

(xorg is an alias and in this case I installed ALL :O, just in case).

At first I did the install of nvidia and nvidia-utils nvidia-304, driver BUT doesn't have the correct version of the drivers that I need. so I have to uninstall later to install the correct one.

Something to remember if you install nvidia-lts you need to install kernel-lts and header-lts, and re run mkinitcpio -p.

nvidia-xconfig to set Xorg configuration. See Also nvidia-settings and nvidia-smi.

nouveau-dri I tried to install the open source driver but was a failed, after many modprobe and rmprobe with nouveau and nvidia and debuging with modinfo -p video, lshw -c video, so I install the legacy driver from an AUR package with the tool "yay" is a client writen on golang, and is easy to use and install from Cli.

Cinnamon package to see sections:

$ pacman -Ql cinnamon | awk -F '[_.]' '/cs_.+\.py/ {print $2}'

8 - generar fstab

genfstab -pU /mnt >> /mnt/etc/fstab

9 - the chroot to make some configurations and installing the grub in the new uefi partition.

arch-chroot /mnt

10 - without GUI, setting configuration files, service, and customizations:

hostname:

echo "CoolName" >> /etc/hostname

   Timezone:

       ln -sf /usr/share/zoneinfo/America/Buenos_Aires  /etc/localtime

   Setting Locale:

       uncomment a line on this file "/etc/locale.gen" and run the command cli  $ locale-gen

   Setting keymap:

         localectl list-keymaps | grep -i us  (list all available keymaps)

         echo "KEYMAP=us" > /etc/vconsole.conf  (do the setting)

   Making grub config file:

         echo "GRUB_DISABLE_OS_PROBER=false" >> /etc/default/grub (edit /etc/default/grub)

         grub-install --efi-directory=/boot/efi --bootloader-id="Archlinux" --target=x86_64-efi --removable

         os-prober (testing if we have another OS like windows)

         grub-mkconfig -o /boot/grub/grub.cfg

    Adding a new user to use with sudo:

        useradd -m -g users -G audio,lp,optical,video,wheel,games,power,scanner -s /bin/bash j3nnn1

        passwd j3nnn1

    Installing nvidia driver via Yay:

        - git clone https://aur.archlinux.org/yay.git

        - cd yay

        - makepkg -si (don't forget to add this user to sudoers file)

        - if you run without -i use pacman -U package.gz (optional)

        - yay -S nvidia-390xx-dkms

        - yay -S google-chrome

        - yay -S numix-gtk-theme

    Setting  Time:

        - timedatectl set-ntp true. (only if you did previously the setting of timezone on the file: /etc/localtime)

        - timedatectl timesync-status

        - timedatectl status

    Related to Kernel:

        - mkinitcpio -P

    Enable display manager and network manager and GUI:

        - systemctl enable lightdm

        - systemctl enable NetworkManager

        - systemctl isolate  graphical.target ( testing graphical UI, on next reboot will be dismiss this change)

        - systemctl set-default multi-user.target (CLI)

        - systemctl set-default graphical.target (GUI)

        - systemctl get-default

11 - enable GUI.

     - systemctl set-default graphical.target (GUI)

12 - disable GUI (troubleshooting).

     - systemctl set-default multi-user.target (CLI)

13 - testing with startx (xorg-xinit and xorg-apps should be installed)

- edit file "~/.xinitrc".

vim ~/.xinitrc

echo "exec cinnamon-session" > ~/.xinitrc

- from CLI execute: startx

And That's all.

By now..

Sorry about the Spanglish and grammatical errors.

14 - tools nvidia

is loaded nvidia driver?

dkms install --no-depmod nvidia/390.144 -k 5.15.3-arch1-1 && depmod 5.15.3-arch1-1

Logs

cat /var/log/Xorg.0.log

Blacklist noveau

caracas# cat /usr/lib/modprobe.d/nvidia-390xx-dkms.conf
blacklist nouveau

When The Xorg Server API is not compatible with the driver:

caracas# cat /etc/X11/xorg.conf.d/20-server_flags.conf

Section "ServerFlags"
Option "IgnoreABI" "1"
EndSection

cat /usr/lib/modprobe.d/nvidia-lts.conf

update nvidia driver with new API

..@TODO

References:

https://wiki.archlinux.org/title/NVIDIA#Installation

gdm locked user.

vim /etc/security/faillock.conf

deny = 9999

tools en linux

2021-08-08T19:08:00.004-04:00

generar clave de 4 palabras.

shuf -n4 /usr/share/dict/words | tr -d '\n'

todas las ips conectadas a mi host.

netstat -lantp | grep ESTABLISHED |awk '{print $5}' | awk -F: '{print $1}' | sort -u

chequear sintaxis

find . -name \*.php -exec php -l "{}" \;

listar solo directorios.

find . -maxdepth 1 -type d | sort

recuperar archivos y se ejecuta como root o con sudo.

testdisk

listar tamaño de uso de un archivo o directorio:

du -h . | egrep -i j3nnn1/santiagozarate$

eliminar procesos luego de una búsqueda.

ps -fea | grep perl | awk '{print $2}' | xargs kill -9

matar un proceso zombie

dhcpcd zombi kill -HUP `ps -A -ostat,ppid,pid,cmd | grep -e '^[Zz]' | awk '{print $2}'`

Apuntes varios de GraphQL

2021-08-08T09:56:00.004-04:00

What is GraphQL? Is a query language and it’s focused on data manipulation of APIs, like an abstraction layer that lets us have many sources of data (Relational Database, APIs, documents databases, key-values databases) attached to one entrypoint, that let us filter fields from the client and take only the attributes/columns/data that we need and get in the response only what we defined as needed data.

Why use GraphQL in this process? because it is designed to make APIs fast, flexible, and developer-friendly. It can even be deployed within an integrated development environment (IDE) known as GraphiQL. As an alternative to REST, GraphQL lets developers construct requests that pull data from multiple data sources in a single API call. GraphQL gives API maintainers the flexibility to add or deprecate fields without impacting existing queries, that’s a plus to avoid errors from versioned API and have a lower impact on production changes.

Things to take into account when we iterate over a product API:

Schema first design: The first thing you must do is agree on a schema with the team who will be building the backend. This will save a lot of refactoring later on, and if all goes according to plan you will be able to swap out the MockedProvider for the real one and your application should work seamlessly.
Design and implement with the user in mind.
Remember API retirement and change Management.

Common GraphQL terms.

Graphql is a strongly typed language[1] this means that Graphql defines various data types to define the schema in this way is a fixed contract between client and server, so we communicate in the same way with each request, and allows us to talk about GraphQL schemas in a language-agnostic way (we don’t care if we are using javaScript, java or golang).

The most basic components of a GraphQL schema are object types, which just represent a kind of object you can fetch from your service, and what fields it has.

Some of Type System’s schema are:

Object Type
Fields
Query
Mutations
Array
List
And a set of default scalar types out of the box: Int (a signed 32 bits), float (A signed double precision), String (UTF-8 character sequence), Boolean (true or false), ID (The ID scalar type represents a unique identifier).

After we did a resume about the type system of Graphql, we could use several tools to mock data into this services, one of them is:

- Apollo graphql (server/client)

- mock.io/graphql ( it’s no a free, you’ll have to pay to used it)

- hasura.io[2] (server, works with apollo client or any client for graphql) is an open source service that gives you production-grade APIs on your data without having to build, operate & scale a GraphQL server. This has a developer tier free. You could try it.

Advantages and Drawbacks of GraphQL.

Advantages.

Reducing the amount of data returned between your frontend and the backend. Solves the issue of over-fetching or under-fetching data. Over-fetching is fetching all the data from an endpoint, but using only a portion of that data for, say, a mobile application. Under-fetching is fetching all the data from an endpoint, but not having enough data. This usually requires a call to a second endpoint.
Developers can build APIs with whatever methods they prefer, and the GraphQL specification will ensure they function in predictable ways to clients without impacting existing queries.
Aggregate that data together into a single meaningful response. GraphQL can be set up to call multiple backend services as it assembles its query response.
GraphQL is a way to simplify the interactions with your backend data, by using an interface whose schemas describe the system behavior so you can get efficient data from your APIs, bringing you flexibility in retrieving information. has general usefulness for simplifying the use of complex APIs.
Can be scalable using Apollo Federation[3], in this way you have one entrypoint (GraphQL Schema Server) and many implementations of resolvers behind this schema. Apollo Federation encourages a design principle called separation of concerns. This enables different teams to work on different products and features within a single data graph, without interfering with each other. This promised the benefits of a unified schema with distributed ownership and implementation.

Drawbacks.

The basic framework cannot be avoided. You have to do things according to the GraphQL way.
GraphQL presents a learning curve for developers familiar with REST APIs.
GraphQL shifts much of the work of a data query to the server side, which adds complexity for server developers.
API maintainers have the additional task of writing maintainable GraphQL schema.

Tools on GraphQL.

strapi, allow you to auto generate documentation from GraphQL schemas. https://strapi.io/documentation
hotchocolate, .Net Platform to implement a GraphQL server (C#).

https://github.com/ChilliCream/hotchocolate

Offix, an offline client that allows GraphQL mutations and queries to execute even when an application is unreachable.

https://offix.dev/

Graphback, a command line-client for generating GraphQL-enabled Node.js servers.

https://graphback.dev/

OpenAPI-to-GraphQL, a command-line interface and library for translating APIs described by OpenAPI Specifications or Swagger into GraphQL.

https://github.com/IBM/openapi-to-graphql

Links referenced.

[1] https://graphql.org/learn/schema/

[2] https://hasura.io/

[3] https://www.apollographql.com/docs/federation/

Apuntes varios de yum y mis aventuras con rpms.

2021-01-15T11:58:00.001-04:00

esto es un respaldo de mis post it, que suelo tener en el escritorio.

yum groupinstall 'MySQl'

yum groupremove 'MySQl'

yum repolist all

yum --enable-repo=epel install phpmyadmin

yum clean all

yum shell

yum history

yum -y [install | remove | update] firefox

yum exacto list firefox

yum * search

yum info firefox

yum provides /etc/httpd/conf/httpd.conf

yum grouplist

rpm -qi <pkg>

rpm -qpl <pkg> listar los archivos que el paquete tiene.

rpm -qpc <pkg> lista los archivos de configuración que tiene el paquete.

rpm -qp --changelog <pkg> ver cambios asociados a bugfixes con el paquete.

Raspberry Pi 4

2020-09-24T09:58:00.004-04:00

Hola! dejo anotaciones cada vez es más fácil usar estas cositas, y hay nuevas cosas y herramientas que son faciles de usar pero me olvido de todo asi que lo anoto por acá.

¿Qué utilizar para instalar el sistema operativo?

- imager, esta interfaz es muy practica y facil de usar, es un software que se baja de la pagina o de los repositorios oficiales de cada distribucion, sino en la página de raspberry pi: creo que bajé la imagen:

raspberryRaspberry Pi Desktop, y automagicamente inicia el entorno de escritorio si tiene conectado un monitor o tv.

https://www.raspberrypi.org/downloads/

- ¿dd if of ? anteriomente usaba esto pero ando en modo chusmeando lo nuevo.

- etcher https://www.balena.io/etcher/

- raspberry-pi-imager

sudo apt install rpi-imager. (www.raspberrypi.com/software/)

https://www.raspberrypi.com/documentation/computers/getting-started.html#raspberry-pi-imager

¿Donde bajar la imagen a instalar?

- hay una imagen de debian que ya viene con el escritorio.

- la version LITE viene sin entorno de escritorio lo que es practico si solo la quieres usar para algo X como octoprint, pyhole, y asi.

https://www.raspberrypi.org/downloads/

* Viene con mini hdmi y no tengo monitor pero no es necesario instalar un entorno grafico, para comenzar a usarla, solo se necesita editar un archivo de config de /boot. y colocar el usuario y password del wifi, esto es lo que llaman headless te permite habilitar ssh y configurar wifi:

para wifi: en /boot/wpa_supplicant.conf OR /etc/wpa_supplicant/wpa_supplicant.conf

ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev

update_config=1

country=AR

network={

ssid="<ssid>"

psk="<password>"

}

Algo que sirvió es colocarle una ip statica en la interfaz de la wlan0 en el archivo:

/rootfs/etc/dhcpcd.conf en caso que falle el dhcp usara esta config como fallback, y tendremos acceso por SSH.

Algo así está en el archivo:

# It is possible to fall back to a static IP if DHCP fails:
interface wlan0
static ip_address=192.168.0.24/24
static routers=192.168.0.1
static domain_name_servers=8.8.8.8

y para revisar config:

sudo iwlist wlan0 scan

ifconfig wlan0

Activar el servicio de dhcp:

luego volver a comentar estas lineas (/rootfs/etc/dhcpcd.conf) sobre la ip estática sino revisar en el router que nadie mas tenga esa ip. y colocarla como fija a este dispositivo.

para ssh:

For headless setup, SSH can be enabled by placing a file named ssh, without any extension, onto the boot partition of the SD card from another computer. When the Pi boots, it looks for the ssh file. If it is found, SSH is enabled and the file is deleted.

ssh pi@<IP>

* Otro problemita que tuve es la autodeteccion del monitor si esta apagado y la raspberry estuvo encendida, a veces no detectaba el plug in del monitor, tambien editando unos parametros del archivo :

se cambian las configuraciones necesarias: /boot/config.txt

# uncomment to increase signal to HDMI, if you have interference, blanking, or

# no display

config_hdmi_boost=7

y se agrega export DISPLAY=0.0 y startx&

* Cada tanto hay un error de audio, es decir no detecta correctamente cual de las salidas de audio deberia utilizar, pero evitar esto es mejor definirle una salida de audio directamente,

# Force the monitor to HDMI mode so that sound will be sent over HDMI cable

hdmi_drive=2

* Una cosa que instale fue kodi, esto me falta pulir un poco mas porque esta poco configurado:

sudo apt-get install software-properties-common
sudo aptitude install kodi
sudo apt-get install kodi-audiodecoder-modplug

sudo apt-get install kodi-audiodecoder-nosefart
sudo apt-get install kodi-audiodecoder-sidplay
sudo apt-get install kodi-audiodecoder-sneapu
sudo apt-get install kodi-audiodecoder-snesapu
sudo apt-get install kodi-audiodecoder-stsound
sudo apt-get install kodi-audiodecoder-timidity
sudo apt-get install kodi-audiodecoder-vgmstream
sudo apt-get install kodi-visualization-goom
sudo apt-get install kodi-visualization-projectm
sudo apt-get install kodi-visualization-projectm
sudo apt-get install kodi-visualization-shadertoy
sudo apt-get install kodi-visualization-spectrum
sudo apt-get install kodi-visualization-waveform
sudo apt-get install kodi-visualization-fishbmc

La raspberry py 4 no usa codecs para videos lo cual es bueno!.

configuración adicional:

sudo raspi-config

Algo importante es la temperatura es recomendable instalar lm-sensors:

pi@ona:/bin $ sensors
cpu_thermal-virtual-0

Adapter: Virtual device temp1: +38.0°C

rpi_volt-isa-0000

Adapter: ISA adapter in0: N/A

Setting locale and lang.

sudo raspi-config

installing pi hole.

como soy media vaga use la version automatizada de la instalación:

https://github.com/pi-hole/pi-hole/#one-step-automated-install

curl -sSL https://install.pi-hole.net | bash

luego hago el set del dns en cada cliente.

/etc/resolv.conf

nameserver <IP pihole>

tiene GUI:

View the web interface at http://pi.hole/admin or │

│ http://192.168.0.20/admin

Your Admin Webpage login password is XXXXXX

Como fibertel no te deja editar el dns en el router queda

- cambiar a un router particular o

- hacer los sets del dns en cada cliente.

Múltiples versiones de java

2020-07-20T11:44:00.004-04:00

variables de ambiente que tengo que definir usualmente:

export JAVA_HOME=/usr/lib/jvm/jdk1.6.0_37
Configurar la variable JRE_HOME.

# export JRE_HOME=/usr/lib/jvm/jdk1.6.0_37/jre
Configurar la variable PATH.

# export PATH=$PATH:/usr/lib/jvm/jdk1.6.0_37/bin:/usr/lib/jvm/jdk1.6.0_37/jre/bin

export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.232.b09-0.el7_7.x86_64

export JRE_HOME=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.232.b09-0.el7_7.x86_64/jre

Las diferentes versiones de openjdk(s) se guardan en:

/usr/lib/jvm/

Otra ruta importante de java eso un symbolic link en:

/usr/lib/jvm/default <- el sistema utiliza esto por defecto en cualquier dependencia

/usr/lib/jvm/default-java <- ubuntu

Se guarda un enlace simbolico a la version por defecto de java

ls -l /etc/alternatives/java

Cambiar de java version, con versiones instaladas por paquetes (ubuntu)

update-java-alternatives --list

sudo update-java-alternatives --set /usr/lib/jvm/java-1.8.0-openjdk-amd64

OR

sudo update-java-alternatives --jre-headless --jre --set java-1.8.0-openjdk-amd64

sudo update-alternatives --config java
sudo update-alternatives --config javac

Como instalar multiples java en centos.

sudo yum install java-1.8.0-openjdk.x86_64

Esto instala aca:

[centos@ip-10-0-100-147 lib]$ whereis java
java: /usr/bin/java /usr/lib/java /etc/java /usr/share/java /usr/share/man/man1/java.1.gz
---------------------------------------------------------------------------------------------
/usr/bin/java -> /etc/alternatives/java
-----------------------------------------------------------------------------------------------
/etc/alternatives/java -> /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.232.b09-0.el7_7.x86_64/jre/bin/java

Copiar las nuevas versiones en el path o instalar por el gestor de paquetes la version de jdk:

/usr/lib/jvm/

y ejecutamos (solo centos):

alternatives --install /usr/bin/java java /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.232.b09-0.el7_7.x86_64/jre/bin/java 1

alternatives --config java

también se tiene que actualizar (solo centos):

alternatives --set jar /usr/lib/jvm/java-8-openjdk-amd64/bin/jar

alternatives --set javac /usr/lib/jvm/java-8-openjdk-amd64/bin/javac

Learning about k8s

2020-06-14T12:34:00.015-04:00

Today in agile teams is crucial embracing a GitOps Model to achieve a major level of maturity of process development, and thus evolving the product faster, the goals should be small in the way we could iterate over it.

When I write about “maturity levels” I refer to automation of traceability, configuration, and secret management, least privilege access.

The term GitOps was coined by Alexis Richardson at Weaveworks around 2017 [1] where he explained that.

Some people could see the GitOps term like the next level in the process development, I think could be a level up from the “DevOps” term in the process development.

It is a new way of looking at the operation process.

Before dive into something practical we need to recall which are the principles of GitOps:

Infrastructure as code (IaC): allows us to treat the configuration of infrastructure and deployment of code in the same way how we usually manage the software development process using a familiar tool: Git. Some references you could find definitions like “Git as a single source of truth” this means using Git to operate almost everything, even configuration, and secrets.

Self-Service: GitOps flow aims to break the barrier by automating and making it self-service (a pull request and code review). In this way, we as developers are close to the operation or deployment of environments in a simple way.

Declarative infrastructure configuration: In several references they recommend the use of a pure declarative infrastructure configuration, is an easy and simple way to map the state of our deployment and is more intuitive. This type of configuration lets us do code review, comments and pull requests of configuration files.

Observability: We need software agents to ensure correctness and alert on divergence in our system, we need alerts, healthchecks, that inform us if something went wrong with some element or application, checking through Git the desired state of system against the actual state, and doing the best to self-healing.

Taking this into account you could improve stability, higher reliability, consistency, and Standardization, also this could enhance the development experience making transparent the deployment process (with a commit approved you could deploy in a simple way, because Git is the source of true).

We could use these principles without using kubernetes, You could choose the tech stack that adjusts more to your situation or platform. In this blog we use minikube in a practical way making a review about subjects on GitOps and how kubernetes (minikube) help us to understand the flow of gitops.

Kubernetes was first developed by a team at Google, they called Borg around 2003 [2] in the middle of 2014 Google presented Borg in an open-source version called “Kubernetes” the definition is “Kubernetes is an open-source reference implementation of container cluster management.”[3] In several bibliographies you could find Kubernetes term abbreviated like “k8s” so from now on I will refer to Kubernetes in this way.

The k8s cluster should subscribe to changes made in a repository. So the first requirement we have is having a Git repository. You could use github[5], gitlab[4], bitbucket [6]. Second you need to install minikube, this is a software that lets you try basic commands from a k8s cluster and test the development workflow[7].

Install minikube:

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube_latest_amd64.deb
sudo dpkg -i minikube_latest_amd64.deb

After this you could see something like this:

Selecting previously unselected package minikube.
(Reading database ... 332649 files and directories currently installed.)
Preparing to unpack minikube_latest_amd64.deb ...
Unpacking minikube (1.11.0) ...
Setting up minikube (1.11.0) ...

You could choose how to use minikube, I mean how k8s will compose the pod (later we see this term), only you have to set up the driver.

Stable drivers are docker, virtualbox, VMWare, Parallels, kvm, Hyperkit, Hyper-V. In an experimental and active development is podman.

$ minikube start --vm-driver=virtualbox

If “vm-driver” is blank by default minikube will use docker. Once you created the cluster with a specific driver you couldn’t start with another driver type (you’ll get an error when you do it). I will create the cluster with the docker driver, so I executed without setting the driver. This will be a little slow the first time only because is pulling all images, the next execution will be faster, you will see sometime like this:

Output:

➜ /tmp minikube start
😄 minikube v1.9.0 on Ubuntu 18.04
✨ Using the docker driver based on existing profile
🚜 Pulling base image ...
🔄 Restarting existing docker container for "minikube" ...
🐳 Preparing Kubernetes v1.18.0 on Docker 19.03.2 ...
▪ kubeadm.pod-network-cidr=10.244.0.0/16
🌟 Enabling addons: dashboard, default-storageclass, storage-provisioner
🏄 Done! kubectl is now configured to use "minikube"

Installing kubectl:

After that you need another tool “kubectl” that lets you manage (create, update and delete) the k8s resources, kubectl supports imperative commands as declarative commands. About the installation you could use you package manager or download and install in this way[8]:

$ curl -LO https://storage.googleapis.com/kubernetes-release/release/`curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt`/bin/linux/amd64/kubectl
$ chmod +x ./kubectl
$ sudo mv ./kubectl /usr/local/bin/kubectl
$ kubectl version --client

Output:

➜ /tmp kubectl version --client
Client Version: version.Info{Major:"1", Minor:"18", GitVersion:"v1.18.3", GitCommit:"2e7996e3e2712684bc73f0dec0200d64eec7fe40", GitTreeState:"clean", BuildDate:"2020-05-20T12:52:00Z", GoVersion:"go1.13.9", Compiler:"gc", Platform:"linux/amd64"}

We are going to mention the elements in a k8s cluster: In a k8s cluster, you could find a master and nodes at first Level. At least one node should exist, a node is representing a virtual or physical machine. Where each node has elements like kubelet, kubelet proxy, Pods, and some add ons related to Dns, UI[9].

Listing Nodes in a cluster:

➜ Desktop kubectl get nodes
NAME STATUS ROLES AGE VERSION
minikube Ready master 34h v1.18.0

K8s Cluster:

Master
nodes

K8s Node:

Kubelet
Kubelet Proxy
Pod(s)

K8s Master:

Etcd
Controller manager
Api server
Scheduler
Cloud manager

A Pod is the smallest unit in k8s cluster, they are representing a running process in a cluster. You could have more than one container in a pod. In this example, we have docker containers in each pod because we selected that driver at the beginning when we init our cluster with minikube.

Creating a Pod (this command will add the pod to the default namespace later we explain this):

➜ /code kubectl run db --image mongo
pod/db created

Another way to create a pod is using a yml file that defines our deployment in a declarative way, this is the recommended because it is following one of the GitOps principles, when we talk about a declarative way we define in a yml the desired state we want.

In an imperative way we put steps one after another or execute commands in order to get the desired state, i.e: when I execute kubectl run and later kubectl delete.

The next links are yml examples In a declarative way, the first one nginx-pod will create a pod using two docker images: nginx and docker/whalesay, but the final result is one docker container, showing “Hello kubernetes” in a html file. The second one will create another docker container with a mongodb instance. You shouldn’t mix declarative and imperative commands in a deployment.

Using a declarative way to create a Pod.

kubectl create -f pod/db.yml

Listing Pods in a node with the default namespace:

Add -o wide to get more information or to specify a format like json or yaml.

➜ /code kubectl get pods
NAME READY STATUS RESTARTS AGE
db 1/1 Running 0 91s

Listing pods running in a cluster:

kubectl get pods --all-namespaces

Describe POD:

When I read for the first time this command, I related it to the command docker inspect, when we need information about the pod, we could get it with this command, the output is extensive and have a lot of information: the more relevant items are namespace, status could be pending or running, node, Start Time, Restart Count, and Event related to it:

➜ k8s git:(master) ✗ kubectl describe pod db
Name: db
Namespace: default
Priority: 0
Node: minikube/172.17.0.2
Start Time: Thu, 11 Jun 2020 16:07:26 -0300
Labels: type=db
vendor=MongoLabs
Annotations: <none>
Status: Pending
IP:
IPs: <none>
Containers:
db:
Container ID:
Image: mongo:3.3
…

Events:

Type Reason Age From Message

---- ------ ---- ---- -------

Normal Scheduled <unknown> default-scheduler Successfully assigned default/db to minikube

Normal Pulling 7m47s kubelet, minikube Pulling image "mongo:3.3"

Normal Pulled 6m57s kubelet, minikube Successfully pulled image "mongo:3.3"

Normal Created 6m56s kubelet, minikube Created container db

Normal Started 6m56s kubelet, minikube Started container db

...

A Pod in “Running” state means that all containers successfully started, and the db Pod is ready to serve requests. If the db pod in your cluster is running, then we can try accessing it or executing a well known “ps” command to prove that it is actually working. We’ll kill the mongodb process (change the deployment state) and we’ll could observe that k8s will do the necessary to bring us the desire state defined in the yml file:

Executing a command inside a POD in the first container that found, use -c to specify a container (remember a pod could have multiple containers).

➜ k8s git:(master) ✗ kubectl exec db -- ps aux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.8 0.2 286084 59136 ? Ssl 19:08 0:26 mongod --rest --httpinterface
root 29 0.0 0.0 17496 2036 ? Rs 19:59 0:00 ps aux

Accessing to the POD (running a shell inside the container):

➜ kubectl exec -it db -- sh

Killing a process inside the container and getting pod status:

You could see the Restarts column increase in one, this k8s features let us keep redundancy and stability. Remember the fourth principle where we have a software agent checking the actual state vs the desired state of application, and making actions to achieve the desired state defined in the Yaml file.

➜ k8s git:(master) ✗ kubectl exec -it db -- pkill mongod
➜ k8s git:(master) ✗ kubectl get pods
NAME READY STATUS RESTARTS AGE
db 0/1 Completed 2 75m

To delete the pod:

After this practical we could delete the Pod to become a new practical and the last one. Also you could delete the entire deployment and the pod will be deleted too:

➜ kubectl delete pod db
pod "db" deleted

➜ kubectl delete deployment db

➜ kubectl delete -f pod/db.yml #declarative way

A deployment contains nodes, pods, use images, and all defined in a yml file called the manifest. The deployment could be organized by namespace, also you could use annotations to select objects/resources. The first part of a yml file declarative with a deployment looks like:

We set three replicas, some metadata “environment” and “organization”, and we specified the nginx image in the container. The Yml file with this kind of definition is called “manifest”

apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx-declarative
annotations:
environment: prod
organization: marketing
spec:
replicas: 3
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:latest

Creating a deployment:

Download it the file, from:

https://gitlab.com/j3nnn1/blogspot/-/blob/master/blogspot2/k8s/step2/declarative-deployment.yaml

➜ step2 git:(master) ✗ kubectl apply -f declarative-deployment.yaml

deployment.apps/nginx-declarative created

Listing deployment:

➜ step2 git:(master) ✗ kubectl get deployments

NAME READY UP-TO-DATE AVAILABLE AGE

nginx-declarative 3/3 3 3 63s

Update a deployment:

If you edit declarative-deployment.yaml you couldn’t see the change immediately in the k8s cluster, to see the changes edited in the file you need to execute the command kubectl apply or kubectl patch, an alternative is use watch with this command kubectl will subscribe to changes made into the declarative-deployment.yaml. And when you update the deployment you could see the output message change a little bit when you created the deployment.

➜ step2 git:(master) ✗ kubectl apply -f declarative-deployment.yaml
deployment.apps/nginx-declarative configured

In a GitOps flow you have an element that maintains an infinite loop and continuously reconciles the desired and actual state, checking if a change was made to this file, are called controllers. There are many patterns to implement a controller[10], K8s comes with built-in controllers and you also could write it in different languages, the controller should use the API server to manage the cluster. It’s recommended that we have many simple controllers instead of one monolithic controller, I.e use a controller for each rk8s resource to manage. And when we talk about automation we need to include a new term the GitOps operator [11] tha lets automate a task beyond what Kubernetes itself provides.

There are many tools to implement CI/CD. Some of these tools are: graden.io, skaffold, Draft, Squash, Helm, Charts, Ksonnet, Fluxcd, Argo CD. The path is the same, you should choose the option more suitable for the environment or kind of software application, there is no unique way or a magic equation to apply these principles, each company has different needs and structure.

1 https://www.weave.works/blog/gitops-operations-by-pull-request

2 https://research.google/pubs/pub43438/

3 https://github.com/kubernetes/kubernetes/commit/2c4b3a562ce34cddc3f8218a2c4d11c7310e6d56

4 https://about.gitlab.com/

5 https://github.com/

6 https://bitbucket.org/

7 https://minikube.sigs.k8s.io/docs/ “minikube is local Kubernetes, focusing on making it easy to learn and develop for Kubernetes”

8 https://kubernetes.io/docs/tasks/tools/install-kubectl/

9 https://kubernetes.io/docs/concepts/overview/components/

10 https://kubernetes.io/docs/concepts/extend-kubernetes/extend-cluster/#extension-patterns

11 https://kubernetes.io/docs/concepts/extend-kubernetes/operator/

PD: sorry for any grammar mistake made in the text, send corrections if you want.

DHCP resumen de lo que leí alguna vez.

2020-05-03T20:51:00.002-04:00

- Utiliza el puerto 67 (Servidor) y 68 (cliente) Para IPv4
- Utiliza el puerto 547 (Servidor) y 546 (cliente) Para IPv6
- Maneja mensajes del tipo broadcast y unicast.
- Para IPv4 son 4 tipos de paquetes:

Discover (broadcast)
Offer (broadcast)
Request (broadcast) (Put server id en el paquete)
Ack (unicast?)

- Para IPv6 son:

Solicit
Advertisement
Request
Reply

- En un dhcp server se definen scopes, que se componen de:
- range
- lease duration
- mask appress
- client
- default gateway

De acuerdo a un RFC se definieron opciones aca menciono algunas que anote:

Option 53: message type
Option 6: domain server
** Option 1 es requerido y tiene la máscara de red.
Option 3: Router ip
Option 150: tftp server ip
Option 51 lease time

Nota: cuando un cliente va a renovar la ip porque ya expiro el tiempo de su lease, envia un mensaje por unicast (REQUEST) y le devuelven un ACK con el lease del time nuevo.
Esto lo realiza por 3 T.

T1
..
T2
..
y al tercero de acuerdo al rfc creo, genera otro broadcast con el request del lease time y si no responde nadie queda marcado como que expiro, es dropeado este mensaje y vuelve al estado inicial...

El discover

Y eso es todo amigos, tirando papeles!

PD: esta sujeto a edición es de uno de los apuntes que alguna vez hice a mano, y quizas mal entendi algun paso :P

Sobre pluralsight free april month, data, cuentos, visualizaciones

2020-05-03T20:03:00.000-04:00

buenas buenas,

Ahora en free april month existió la promoción que permitía acceder al contenido de cursos online, no se si aún continua, pero pueden chusmear en este link:

https://www.pluralsight.com/offer/2020/free-april-month

Como me olvido de todo decidí agregar este artículo resumen de las cosas relevante que me llamaron la atención y esta bueno recordar. De los cursos que revisé en base a la fecha de publicación (elegir los más nuevos) estan:

https://app.pluralsight.com/library/courses/storytelling-to-engage-motivate/table-of-contents

y

https://app.pluralsight.com/library/courses/data-visualization-best-practices/table-of-contents

vi otros que no parecieron buenos, así que ni los menciono. Entre los puntos o anotaciones importantes sobre las visualizaciones y storytelling, menciono:

storytelling:

- Elementos que ayudan a hacer una historia efectiva, logrando una efectiva comunicación.
- Arquetipos de un "cuento" o ser un cuentacuentos? o storytelling? efectivo

mencionan que existen estos frameworks:
1 -"Stranger goes to town man goes on a journey" se refiere a jornadas de viaje metafóricas.
2 - Comedy vs Tragedy. (comedy = survival of community, and tragedy = indivual failure)
3 - the hero quest.
4 - The rags to rich story. (cuando comienza de 0 o la nada misma y llega a un punto cumbre final de exito)
5- The fall. (es el punto 4 invertido.. del exito va al fracaso.)
6 - Mistery (desde un punto o sujeto incognito explica los elemento necesarios para hallar el punto cumbre y develar quien o como llego a ese punto cumbre)
7 - Romance (aca menciona un poco relacionado a una publicidad donde usar el romance para explicar que solemos tener un afecto mayor por nuestros telefonos ya que pasamos mucho tiempo con esto)

- Tres U de una historia (todas comienzan con la palabra understand, en español podría ser las tres E de una historia o cuento).
1 - fuentes
2 - audiencia
3 - cada tipo de dato o términos de negocio.

- Como elegir tipos efectivos de gráficos.
- Mejorando atributos (explica muy por encima el procesamiento de datos)
- Contexto => Who, What, How
- Mencionan de usar herramientas como Qlikview, D3, Tableau.

Data visualizations:

- Encontrar data que comunique un mensaje.
- Sobre la alineación del texto: números (alineación a la derecha), texto (alineación a la izquierda)
- Recomienta los gráficos de barra en porcentajes, en lugar de un número fijo y que sean de orientación horizontal, de esta forma considera que es más fácil de interpretar.
- Wafle charts donde cada cuadro es un % de un total, recomienda si es posible sino el grafico de barras en cascada.
- usar color y tamaño para enfatizar una idea.

Que cosas evitar:

- Evitar hacer gráficos complejos .
- Evitar la redundancia de data en las tablas.
- Evitar redundancia de data.
- Usar ejes o etiquetas, recomienda no usar ambas.
- Evitar los gráficos espaguettis (imagen del artículo).
- En cuanto a colores: de un gráfico recomienda usar 2 o máximo 4, más de este número conviene hacer un subgráfico. Y sobre los colores rojo y verde menciona que a veces es mejor evitarlos si no conoces a la audiencia, y menciona como sustito orange para rojo, y azul para el verde.
- En los graficos de graficos de tortas recomienda no usar más 3 slices (trozos o pedazos o partes).

Que cosas repensar si son necesarias:

- gridlines: las grillas a veces pueden evitarse, siempre cuestionar si suman a la visualización, o el mensaje que se quiere transmitir.
- sobre pie charts, recomienda usar los donuts charts en lugar de los pie charts.

- En los gráficos de barra: si aplica ordenar, bien o de mayor a menor o en orden alfabetico.

- Orientación de las dimensiones. tener cuidado con... A veces las barras horizontales son más leibles.
- Multiples series: recomienda utilizar barras, o line plot, también acota la importancia de agrupar estas barras o líneas, en caso de que aplique.
- A veces un gráfico puede ser sustituido por Texto, y muestra ejemplos donde no se necesita un gráfico para transmitir la idea.
- Los gráficos cascadas, son graficos aditivos y ayudan a visualizar que elementos y proporcion componen un total.

Y para cerrar:
Frases zen que menciona: Remove to improve
(yo creo que aplica para todo, mantener las cosas sencillas es mejor que complejizarlas...)

Asi que ya termine de pasar mis notas sobre lo leido, esta un poco más digerido y para no olvidar parte lo agregue acá, esto me recuerda cosas que vimos durante la maestría, me divertía aprendiendo.

Hasta otro artículo digitalizando lo escrito a mano..

Post-its

2020-05-01T22:02:00.000-04:00

Este post va a crear un nuevo tag en este sitio llamado post-it , tengo como costumbre usar esto para anotar comandos utiles que suelo usar y no tengo la cabeza para no olvidarlos, y como esto no lo debe ver nadie, no creo que afecte mucho si lo guardo aca o google keep, en esta forma me gusta mas porque le agrego notas, fotos y formatos, lo voy a dividir en secciones: asi que comienza:

sobre mi compu personal (alias olivetti):

sda1 => tengo un window 7 de hace muchos años no creo que lo actualice quizas la formatee.

sda5 => otra partición de window => mis documentos creo, en general creo una particion de documentos y programas a instalar por si quiero reinstalar al final no he tenido que reinstalar de hecho no suelo usar mucho esta partición.

6,7,9 => linux y otras cosas
6 => raíz (/)
7 => home
9 => misperoles

me paso que no recordé donde había instalado y borré uno de los dos sistemas operativos y archivos guardados.

se rompió linux por algo relacionado el kernel, me olvide la clave (esto solo si no esta encriptado el disco)
(usar un livecd de arch, ubuntu o su distribución favorita.)

#mount /dev/sda6 /mnt
#mount /dev/sda7 /mnt/home
#arch-chroot /mnt
# hacer lo que quiero hacer y no puedo porque esta roto.
#mkinitcpio -p linux

agregar gpg key externa (spotify por ejemplo)

curl -sS https://download.spotify.com/debian/pubkey.gpg | gpg --import -

Problemas con el grub o generar de nuevo el grubfile (groot)

grub-mkconfig -o >> /boot/grubfile.cfg

Eliminar paquete (este lo aprendi pero igual lo agrego.)

Pacman -Rsnc

Pacman -Rd --no-deps

Temas con monitor que reconozca el monitor hdmi/vga o cosas con los monitores (no lo he usado en mucho tiempo.. ya todo lo reconoce y ajusta bien)

xrandr --output vga-1 --mode 1920x1080

Con este post-it me siento como mi mamá

A veces sin intención presiono la funcion de bloqueo de la tecla fn, entonces mi teclado cambia y donde tenía letras ahora solo tengo números, es algo que algunas notebooks tiene como un feature yo no se si estoy de acuerdo como algo positivo, lo cierto es que consegui como desactivarlo.

Presionar simultaneamente.

Fn + Bloq Num

Hazelcast
Java.util.Map => core.IMap (hazelcast) esto lo tenia anotado porque aún estoy aprendiendo de este tema, y es más fácil relacionarlos.

Y eso es todo por ahora esto solo va a tener el tag de linux y postit o post-it
para seguirlos llenando.

Numbers

2020-01-05T20:44:00.001-04:00

Este libro lo consegui creo que por twitter lo lei y me gustó mucho el enfoque diferente para enseñar matemáticas básicas, creo que lo que más me gusto es su forma cercana de redactar y la forma de mostrar diferentes enfoques para analizar un problema.

Me encanto la parte cercana donde muestra el interes y lo explican de forma entendible, es genial que los chicos lean o se les acerque esta información, y tengan concienca de que es un interes, ahorros, conversion de velocidad de descarga y llevar estos conceptos básicos a situaciones reales.

:D

Lo trate de buscar en amazon pero no lo conseguí lo agrego acá en este enlace:

https://filebin.net/q99pnqouoing69nh

esto expira, si no lo consiguen avisenme por twitter, y les paso el archivo por ahí.

Sólo conseguí referencias al actor de inside 9, que entiendo tiene el mismo nombre.

Cosas que quiero regalar y no se como

2020-01-05T17:47:00.001-04:00

4 tools useful to everyday in js

2019-12-30T17:33:00.002-04:00

01 NVM:

When is it useful to use NVM?

* In teams where we have different operating systems.

* When we have to test new things, for example, the testing version for Node.js.

NVM: Installation

Mac:

You can use homebrew. If you don’t know how to install it, you could check here it (https://brew.sh/) and that’s all.

brew install nvm
source $(brew --prefix nvm)/nvm.sh
echo 'source $(brew --prefix nvm)/nvm.sh' >> ~/.profile

Linux:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.34.0/install.sh | bash

The line before will have an output such as this:

Make sure that these lines below are in your ~/.bashrc or ~/.zshrc:

export NVM_DIR="$([ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm")"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" # This loads nvm

$ cd nvm
$ makepkg -s #this will generate an Arch Linux package (nvm.tar.xz).
$ ls -l nvm.tar.xz

$ pacman -U nvm.tar.xz

NVM Usage:

nvm list : List all versions installed on your machine

➜ ~ nvm list
-> system
iojs -> N/A (default)
node -> stable (-> N/A) (default)
unstable -> N/A (default)

NVM install: Install a local version on your machine from the remote list. The remote list could be filtered by another command like: nvm ls-remote for example “nvm ls-remote v11” lists all versions that have v11 as prefix.

nvm use: set in the current terminal the environments variables so all command executed related to Node.js will use the version defined by NVM.

➜ ~ nvm use v10.15.3
Now using node v10.15.3 (npm v6.4.1)

nvm which: show the path to the Node.js bin file.

➜ ~ nvm which v10.15.3
/home/jennifer/.nvm/versions/node/v10.15.3/bin/node

02 Docker container with node js/ angular-cli:

Hub docker contains a thousand images that you could use in your daily tasks at work, in a simple search you could see (https://hub.docker.com/search?q=angular-cli&type=image)

About 1 - 25 of 492 results for angular-cli.

Here is my recommendation to use it in a local environment for a development process: https://hub.docker.com/r/trion/ng-cli/

docker pull trion/ng-cli

When node_modules directory already was generated.

docker run -u $(id -u) --rm -p 4200:4200 -v "$PWD":/app trion/ng-cli ng serve --host 0.0.0.0 --disableHostCheck

In this way, you need node_modules directory inside the directory defined in $PWD variable.

When a node_modules directory is not generated. And that’s all.

first

docker run -u $(id -u) --rm -p 4200:4200 -v "$PWD":/app trion/ng-cli npm install

later:

docker run -u $(id -u) --rm -p 4200:4200 -v "$PWD":/app trion/ng-cli ng serve --host 0.0.0.0 --disableHostCheck

03 Dotenv using a .env file with and avoid versioning

npm install dotenv

Later, create the .env file in the root of your app and add your variables and values to it. Don’t forget to add this file to .gitignore to avoid committing it.

.env
PORT=55555

Server.js
const dotenv = require('dotenv');
dotenv.config();
console.log(`Your port is ${process.env.PORT}`);

4 Cloud solutions:

pendrives y misceláneos

2019-08-25T23:18:00.002-04:00

Este es un post que comencé hace muchos muchos años y cada cierto tiempo agrego cosas para no olvidarme, y me causó gracia al leerlo, ya que hubo una época había un marketing de un pendrive con U3, que venía a ser una especie de partición con aplicaciones ejecutables portables que sólo funcionaban en windows, y luego mutó en algo llamado start key.

más info: https://en.wikipedia.org/wiki/U3_(software)

Por suerte ya no existe más jaja, pero el uso de un pendrive aún se sigue manteniendo para ciertas cosas como instalar un SO, o tener apps portables, tanto como linux como windows en el día a día de alguien de soporte siempre se genera un pendrive que sea booteable para instalar X sistema operativo.

Acá algunas formas de hacer este pendrive booteable para instalar el SO.

Grabar una imagen ISO en un pendrive (desde esa época no ha cambiado nada si y sólo si el pendrive es para bootear un linux y windows de los viejitos).

dd if=sabayon-x86.iso of=/dev/sdX

donde X es la unidad física, pendrive. no debe estar particionado.

dd if=sabayon-x86.iso of=/dev/sdb

Grabar una imagen ISO en un pendrive con U3.
necesito descargar la imagen ISO. solo funciona en windows.
y una aplicación que se llama: Universal U3 Customizer. link:

http://www.mediafire.com/?ozm5y2utare

La imagen ISO a instalar la tengo que renonbrarU3CUSTOM.ISO y dejarla enel directorio BIN del software U3C.
luego ejecutamos U3C.
y listo reboot
Por suerte ya no se usa más y no te venden pendrives más costosos por este tipo de filosofía

Que ha pasado en estos años... (UEFI... cof cof) hace tiempo que no instalaba en una notebook windows, el último que instalé fue win7 o el anterior, pero han cambiado un poco las cosas, tuve líos al intentar instalar windows10 (haciendo soporte técnico familiar) con un pendrive generado desde linux, excepto por esta herramienta:

Grabar un ISO windows10 con woeusb

Tiene una interfaz gráfica pero puedes no usarla, realmente es bastante simple la herramienta y funcionó a la primera lo probé en ubuntu 18.10 y en archlinux con un paquete de aur (https://aur.archlinux.org/packages/woeusb/)

https://github.com/slacka/WoeUSB

En el README pueden encontrar otros repositorios para otras distribuciones

básicamente la línea de la terminal es:

woeusb -v --device /home/j3nnn1/en_windows_7_ultimate_x86_dvd_x15-65921.iso /dev/sdb

-v => modo verbose

--device => el modo de hacer el pendrive si usa todo el almacenamiento o si usa una partición en su lugar se coloca --partition

imagen_de_origen.iso

y la ruta destino es decir en la ruta /dev del dispositivo.

gracias woeusb hizo mi fin de semana.

y Bueno ahora para quien está desde windows puede usar algo llamado rufus, como es windows es click, click, siguiente, siguiente y para más información pueden visitar:

https://rufus.ie/

PD: la fotito es mi querida ona, hace unos años ♥ como cambian... como crecen...

SMB archlinux/ubuntu (SAMBA PA TI)

2019-06-10T22:56:00.002-04:00

0 - paquetes instalados.
extra/samba 4.10.10-2 [installed]
extra/smbclient 4.10.10-2 [installed]

1 -comprobar que el servidor samba este arriba (smb.service y nmb.service)

systemctl status smb.service

puede salir algo así eso nos dice que está detenido el servidor:

* smb.service - Samba SMB Daemon
Loaded: loaded (/usr/lib/systemd/system/smb.service; disabled; vendor preset: disabled)
Active: inactive (dead)
Docs: man:smbd(8)
man:samba(7)
man:smb.conf(5)

systemctl status nmb.service

puede no iniciar si no localiza el archivo /etc/samba/smb.conf, para esto cree un directorio en /media/misperoles/nas_winterfell

si sale OK, UP, o running ya esta instalado. Revisar la configuración con un cliente de samba:

smbclient -L localhost

consulta por nombre de la red.

nmblookup WINTERFELL

1- Agregar el usuario al grupo de sambashare, en el caso de ubuntu mint al instalarlo ya lo agregaba al grupo, en caso de duda verificar en el archivo:

# cat /etc/group | grep sambashare

sino agregarlo asi

# gpasswd sambashare -a your_username

2- en el caso de arch, samba requiere que se agregue el usuario creado

 y que pertenece al grupo samba share. se agrega asi:

# smbpasswd -a samba_user

en el caso de ubuntu ya lo hace is magic!

3- por ultimo agregar los permisos del directorio compartido

en:

/etc/samba/smb.conf

algo asi al final del archivo:

/etc/samba/smb.conf
[media]
  comment = Media share accessible by greg and pcusers
  path = /media/nas
  public = yes
  writable = yes
  browseable = yes
  create mask = 0664
  directory mask = 2775
  force create mode = 0664
  force directory mode = 2775

esto es publico compartido sin contrasenia.

Para configuración con contraseña y usuario:

[archivos]
path = /media/misperoles/nas_winterfell
comment = take a look and save your files here!
public = yes
browseable = yes
guest ok = yes
writable = yes
available = yes
valid users = j3nnn1
create mask = 0664
directory mask = 2775
force create mode = 0664
force directory mode = 2775

los permisos en el directorio compartido es importante, en la nueva instalación que hice

deje chmod 744 sino devuelve error de restriccion por el administrador.

Los paquetes en ubuntu son similares los nombres.

PD: teclado en ingles me comi algunos acentos.

PD: siempre que pienso en samba, me recuerdo a esta cancion

https://www.youtube.com/watch?v=j5AUm_xaE9A (Samba pa ti / santana)

chau

FliSol 2019

2019-05-03T00:48:00.001-04:00

Este año se realizó el flisol en el centro cultural San Martín en la ciudad de Buenos Aires, estuvo muy bueno lleno de actividades, y lo más importante de muchas instalaciones, de mi parte solo pude hacer dos instalaciones, hace un tiempo que no uso Windows y me olvidé de las mañas con las que venía, tarde un montón pero me divertí.

Estuvieron los chicxs de Pvm y code live como una guerra de djs, jajaja mentira esto último no fue así. En dos espacios de tiempo cada grupo se destacó con música alternativa. (no le pregunten a papo)

En una de las instalaciones alguien me planteó la pregunta porque ayudaba en las instalaciones, y al final quede pensativa, de verdad que buena pregunta, lo cierto es que hace un tiempo siempre sacaba un poquito de espacio para participar y ayudar en esto porque veo importante tener alguien a quien preguntar sobre Linux indistinto de la distribución, escuchar charlas o talleres de alguna tecnología, o diversos tópicos, reunirse con amigos.

Me gusta hacer esto porque es un evento que ofrece una alternativa.

Nos vemos el próximo flisol.

Abrazo!

Fotos sacadas de twitter, :D así que deben ser públicas.

DDD