DEV Community: Albert Coronado

Create CI/CD pipelines en Golang

Albert Coronado — Mon, 03 Feb 2025 16:40:47 +0000

Golang CI/CD is a library to build and automate continuous integration and continuous delivery (CI/CD) pipelines. By leveraging Go's concurrency features, efficiency, and robust standard library, devops can create highly customizable and efficient CI/CD pipelines tailored to their specific project requirements. This allows for faster development cycles, improved code quality, and more reliable deployments.

Atention! Is not just for Golang projects. You can create CICD pipelines for all languages and technologies.

Why

Lightweight, flexible and fast.
You can compile the pipeline in order to ofuscate secrets.
Use concurrency, logs, functional programming and other resources of Golang.
Connect to Git servers, SSH remote servers, etc.
Easy to integrate with Github, Gitlab, Cloud and other tools.

How to create a pipeline

Create a module and install the library:

go mod init gocicd-sample && go get -u github.com/acoronadoc/cicd

Create your first pipeline(script.go):

package main

import (
    "log"

    "github.com/acoronadoc/cicd"
)

const repoURL = "git@github.com:acoronadoc/test-repo.git"
const repoBranch = "main"
const repoKey = "./key"

func main() {

    cicd.StartPipe(true,

        cicd.PipeWaitForCommit(repoURL, repoBranch, repoKey, 10),

        &cicd.RepoPipe{Action: func(state *map[string]interface{}) {
            log.Println("Download Commit", (*state)["COMMITID"])

            cicd.ExecuteCommand("rm", []string{"-R", "-f", "./repo"}, []string{})
            cicd.GitCloneSSH(repoURL, repoBranch, "./repo", repoKey)
            cicd.ExecuteCommand("docker", []string{"stop", "app1"}, []string{})
            cicd.ExecuteCommand("docker", []string{"rm", "app1"}, []string{})
            cicd.ExecuteCommand("docker", []string{"run", "-d", "--name", "app1", "-p", "8080:80", "nginx:1.27-alpine3.20"}, []string{})
            cicd.ExecuteCommand("docker", []string{"cp", "./repo/index.html", "app1:/usr/share/nginx/html/index.html"}, []string{})
        }},
    )

}

You have more samples here.

Why I should start using Zig language?

Albert Coronado — Tue, 27 Aug 2024 07:31:03 +0000

Why I should start using Zig language?
What made better than Go or Rust?
How many companies are using it?
Which is his "market niche"?

Tutorial de Mkdocs

Albert Coronado — Fri, 03 May 2024 14:56:30 +0000

Tal como hemos visto en el vídeo Mkdocs es una excelente herramienta que nos permite crear sitios web estáticos fácilmente a partir de ficheros escritos en Markdown. Ideal para sites de proyectos y/o documentación.

Vamos a documentar en este artículo todos los pasos que hemos ido haciendo:

Creando contenedor Docker para trabajar con Python

Mkdocs es una herramienta basada en Python(Hemos trabajado mucho en el canal/blog con este lenguaje). No es obligatorio, pero nosotros hemos creado un contenedor Docker con Python para trabajar usando el siguiente comando:

docker run --rm -it -p 8000:8000 -v .:/mkdocs python:3.9 bash

Básicamente arrancamos el contenedor con el comando "run" con los parámetros: "--rm" para eliminar el contenedor una vez terminemos con el(Así no generamos basura), "-it" para añadir el modo interactivo y una pseudo tty, mapeamos el puerto 8000 con localhost y mapeamos la carpeta actual con la carpeta "/mkdocs" del contenedor.

Una vez dentro del contenedor tenemos un entorno con Python operativo.

Instalando las dependencias de Mkdocs

Para empezar instalaremos Mkdocs y para ello podríamos hacer simplemente "pip install 'mkdocs==1.5.2'" aunque en el vídeo hemos optado por crear un fichero llamado "requirements.txt" con la dependencia dentro "mkdocs==1.5.2" y ejecutar "pip install -r requirements.txt".

Creando nuestro primer proyecto con mkdocs

Un proyecto Mkdocs básicamente se construye en base a un fichero llamado "mkdocs.yml" donde configuramos todas la propiedades del proyecto como: nombre, url, páginas, theme, etc.

Para no empezar con un folio en blanco hemos usado el siguiente comando para que nos creara un esqueleto de proyecto:

mkdocs new project1

Esto nos ha creado una carpeta llamada "project1", el fichero de configuración "mkdocs" y una carpeta llamada "docs" con una primera página.

Servir la página usando el servidor web embedido de Mkdocs

Una vez configurado nuestro site hemos visto como podemos servirlo usando un servidor embedido que trae Mkdocs con el siguiente comando(Debe ejecutarse desde la carpeta que contiene el fichero "mkdocs.yml"):

mkdocs serve -a 0.0.0.0:8000

Generar web estática

Otra opción para servir nuestra web que nos ofrece Mkdocs es generar todos los ficheros estáticos(HTML, CSS y JS) para luego servirlos desde cualquier hosting. Esto lo hemos hecho con el comando:

mkdocs build

Themes

Hemos visto como podíamos instalar diferentes temas de apariencia para darle a nuestro site diferentes aspectos, hemos probado temas como material, terminal o gitbook entre otros. Esto se hace como se instala cualquier módulo de Python:

pip install mkdocs-gitbook
pip install mkdocs-material
pip install mkdocs-terminal

Una vez instalados podíamos ver nuestra web usando estos temas simplemente configurando la etiqueta "theme: <nombre del tema>" en el fichero "mkdocs.yml" o con el parámetro "-t" del comando "mkdocs".

Plugins

Finalmente, mkdocs también nos permite el uso de plugins para extender su funcionalidad. En nuestro caso hemos instalado este plugin para generar el contenido en PDF:

pip install mkdocs-pdf-export-plugin

Hemos configurado el fichero "mkdocs.yml" para que use el plugin:

plugins:
    - pdf-export:
        verbose: true
        media_type: print
        enabled_if_env: ENABLE_PDF_EXPORT
        combined: true

Y con el siguiente comando hemos podido ver como se nos generaba el PDF(Incluso usando distintos temas de apariencia):

export ENABLE_PDF_EXPORT=1

mkdocs build

Despliegue y configuración de infraestructura DevOps para tus proyectos

Albert Coronado — Thu, 18 Apr 2024 13:05:40 +0000

En este vídeo hemos aprendido a montarnos una pipeline de despliegue DevOps real usando cantidad de tecnologías, algunas de las cuales las hemos instalado: Gitlab, Gitlab CICD, Docker hub, Kubernetes(GKE) sobre Google Cloud Platform(GCP) o Kaniko.

Creación de un cluster sobre Google Cloud Platform(GCP)

Este paso lo hemos realizado desde la consola de GCP en https://console.cloud.google.com/ y es bastante visual, con lo que mejor os basáis en el vídeo.

Obviamente, podríamos haber contratado el cluster a través de cualquier otro proveeros cloud como Amazon o Azure o incluso instalar Kubernetes en nuestros propios servidores con K0s, K3s o similares(Tenemos vídeos y artículos de referencia sobre el tema).

Otra mejora hubiera sido contratar el servicio vía Gcloud o Terraform que nos permitía automatizar este paso. Pero esto ya es otra historia.

Configuración de credenciales de Docker Hub para el despliegue

Para poder desplegar sobre Kubernetes necesitamos un "Registry", que básicamente, se trata de un repositorio donde almacenar las imágenes que vamos a desplegar. En este caso, para no liar mas el vídeo, hemos optado por usar Docker Hub, que nos permite usarlo como servicio SaaS y con su capa gratuita nos vale.

Para ello hemos tenido que configurar unas credenciales y lo hemos hecho vía su interfaz web así que es mas fácil verlo en el vídeo que explicarlo en un artículo.

Me guardo para otro vídeo como instalar alguna alternativa como Nexus para tener nuestro propio registry.

Acceso a Google Cloud Platform(GCP) usando la imagen Docker con Cloud SDK

Para conectarnos al Kubernetes sobre GCP hemos optado por hacerlo usando una imagen de Docker que nos provee el mismo Google. Esta imagen incluye de serie cantidad de utilidades para interactuar con GCP y Kubernetes como son: gcloud(Herramienta CLI para interactuar con GCP), bq(Utilidad para interactuar con los servicios de ingeniería de datos de GCP), gsutils(para subir fichero a GCP), kubectl, Helm, etc.

Hemos arrancado el contenedor con el comando:

docker run --rm -it -v .:/poc google/cloud-sdk:latest

Este commando básicamente arranca el contenedor habilitando el modo interactivo(parámetros -it), montando la carpeta actual en la carpeta /poc(parámetro -v .:/poc) y haciendo que se autodestruya al salir del contenedor(parámetro --rm).

Una vez dentro nos hemos logueado en GCP y configurado el cliente de kubernetes(kubectl) para que use nuestro cluster:

# Login dentro de GCP
gcloud auth login

# Configuración de kubectl apuntando a nuestro cluster
gcloud container clusters get-credentials --zone "ZONA DEL CLUSTER" --project "PROYECTO DE GCP" "NOMBRE DEL CLUSTER"

Instalación de Gitlab sobre Kubernetes(GKE) sobre GCP

Para instalar Gitlab hemos usado el siguiente manifiesto de kubernetes(gitlab.yaml):

kind: Namespace
apiVersion: v1
metadata:
  name: gitlab
  labels:
    name: gitlab-namespace
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: gitlab-deployment
  namespace: gitlab
  labels:
    app: gitlab
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gitlab
  template:
    metadata:
      labels:
        app: gitlab
    spec:
      containers:
      - name: gitlab
        image: gitlab/gitlab-ce:16.7.5-ce.0
        env:
          - name: GITLAB_OMNIBUS_CONFIG
            value: "external_url 'http://gitlab-service'"
          - name: GITLAB_ROOT_PASSWORD
            value: "YoutubePlus!"
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  namespace: gitlab
  name: gitlab-service
spec:
  type: LoadBalancer
  selector:
    app: gitlab
  ports:
      - protocol: TCP
        port: 80
        targetPort: 80

Hemos usado el siguiente comando para aplicarlo:

Kubectl apply -f gitlab.yaml

Instalación del Runner de Gitlab

Los Runners de Gitlab son los encargado de ejecutar las tareas de las pipelines de Gitlab CICD y los hay de muchos tipos(locales, amazon, Docker, etc). Nosotros hemos optado por instalar una de tipo kubernetes.

Los Runners se instalan a nivel de grupo, por lo que hemos necesitado primero crear un grupo de gitlab y una vez dentro, ir a la pestaña "CI / CD" y "Runners" para obtener el token necesario para instalarlo(Esto lo podríamos haber automatizado usando el API de Gitlab, por si ha alguien le interesa).

Ya con nuestro token(parámetro registration-token) hemos usado el siguiente manifiesto para instalar el runner(gitlab-runner.yaml):

apiVersion: v1
kind: ServiceAccount
metadata:
  name: gitlab-service-account-sa
  namespace: gitlab
  labels:
    app: native-app
imagePullSecrets:
  - name: registry-credentials    
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: gitlab-service-account-cr
  namespace: gitlab
  labels:
    app: native-app
rules:
  - apiGroups:
      - ''
      - apps
      - autoscaling
      - batch
      - build.openshift.io
      - image.openshift.io
      - route.openshift.io
    resources:
      - services
      - pods
      - pods/log
      - pods/exec
      - pods/attach
      - namespaces
      - replicationcontrollers
      - daemonsets.apps
      - deployments
      - replicasets
      - statefulsets
      - horizontalpodautoscalers
      - cronjobs
      - jobs
      - daemonsets
      - buildconfigs
      - builds
      - imagestreams
      - imagestreamtags
      - buildconfigs/instantiatebinary
      - routes
      - secrets
    verbs:
      - create
      - watch
      - get
      - list
      - update
      - patch
      - delete
      - deletecollection
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: gitlab-service-account-rbcr
  namespace: gitlab
roleRef:
  kind: ClusterRole
  name: gitlab-service-account-cr
  apiGroup: rbac.authorization.k8s.io
subjects:
  - kind: ServiceAccount
    name: gitlab-service-account-sa
    namespace: gitlab
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: runner-0
  namespace: gitlab
spec:
  selector:
    matchLabels:
      name: runner-pod-0
  template:
    metadata:
      namespace: gitlab
      labels:
        name: runner-pod-0
    spec:
      serviceAccount: gitlab-service-account-sa
      serviceAccountName: gitlab-service-account-sa
      containers:
      - name: pod
        image: alpinelinux/gitlab-runner:latest
        command: 
          - "/bin/sh"
          - "-c"
          - |           
            gitlab-runner register \
              --kubernetes-privileged true \
              --non-interactive \
              --run-untagged=false \
              --executor kubernetes \
              --kubernetes-pull-policy always \
              --request-concurrency 10 \
              --name 'My Runner' \
              --kubernetes-image alpine:latest \
              --kubernetes-image-pull-secrets registry-credentials \
              --kubernetes-namespace gitlab \
              --kubernetes-service-account gitlab-service-account-sa \
              --tag-list kubernetes \
              --url "http://gitlab-service/" \
              --registration-token "GR1348941zBB3FQSts6S282gMoNNC"

            cat /etc/gitlab-runner/config.toml

            gitlab-runner run

Hemos usado el siguiente comando para aplicarlo:

Kubectl apply -f gitlab-runner.yaml

Creación de nuestro primer repo y programación de nuestra api python

El siguiente paso ha sido crear nuestro repo de Gitlab y clonarlo(Con cuidado con la URL que te autogenera el Gitlab) usando el comando:

git clone http://URL DE NUESTRO REPO

Hemos añadido dos fichero con nuestra aplicación:

requirements.txt(Contiene las dependencias de nuestra aplicación Python)

fastapi>=0.68.0,&lt;0.69.0
uvicorn>=0.15.0,&lt;0.16.0

main.py(Contiene nuestra aplicación Python)

from fastapi import FastAPI
import uvicorn

app = FastAPI()

@app.get("/")
def root():
    return {"msg": "Hello World"}

uvicorn.run(app, host="0.0.0.0", port=8080)

Dockerfile para generar las imágenes Docker

En nuestro repo también hemos creado un fichero llamado "Dockerfile" que contiene las instrucciones para generar la imagen que vamos a desplegar en Kubernetes:

FROM python:3.9

RUN mkdir /code
WORKDIR /code

ADD requirements.txt /code/requirements.txt
ADD main.py /code/main.py

RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt

CMD ["python", "main.py"]

Chart Helm para el despliegue

También nos falta una carpeta llamada helm que va a contener todos los ficheros con nuestro chart para desplegar el repo:

/Helm/Chart.yaml (Fichero que describe nuestro chart)

name: my-super-app
version: 0.0.1
appVersion: "1.0"
description: Mi Super App

/helm/values.yaml(Valores o variables que configuran nuestro chart)

appname: test1
environment: dev
namespace: test1

image: test1

/helm/templates/deployment.yaml (Template Helm para configurar el despliegue)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ $.Values.appname }}-{{ $.Values.environment }}-deployment
  namespace: {{ $.Values.namespace }}
spec:
  selector:
    matchLabels:
      name: {{ $.Values.appname }}-{{ $.Values.environment }}-pod
  template:
    metadata:
      namespace: {{ $.Values.namespace }}
      labels:
        name: {{ $.Values.appname }}-{{ $.Values.environment }}-pod
    spec:
      containers:
      - name: pod
        image: {{ $.Values.image }}
      imagePullSecrets:
      - name: regcred

/helm/templates/service.yaml (Template Helm para configurar el servicio)

apiVersion: v1
kind: Service
metadata:
  name: {{ $.Values.appname }}-service
  namespace: {{ $.Values.namespace }}
spec:
  type: LoadBalancer
  selector:
    name: {{ $.Values.appname }}-{{ $.Values.environment }}-pod
  ports:
  - protocol: TCP
    port: 8080
    targetPort: 8080

Configurar el Pipeline de despliegue

Esto es quizás lo mas importante del vídeo, en Gitlab CICD, el pipeline de despliegue viene configurado en un fichero en el propio repo llamado ".gitlab-ci.yml". En nuestro caso nos hemos configurado un pipeline con cuatro stages "version", "tests", "build image" y "deploy":

variables:
  KUBERNETES_NAMESPACE: test1
  DOCKER_REGISTRY_HOST: https://index.docker.io/v1/
  DOCKER_REGISTRY_USER: acoronadoc
  DOCKER_REGISTRY_PASSWORD: dckr_pat_GegpqyANy7NViEmIDjNQATERUmM

default:
  tags:
    - kubernetes
  image: alpine:latest

stages:
  - version
  - test
  - build-image
  - deploy

version:
  stage: version
  script:
    - echo "VERSION=$(date +%Y%m%d%H%M%S%N)-$CI_COMMIT_BRANCH" >> build.env
  artifacts:
    reports:
      dotenv: build.env

test:
  stage: test
  script:
    - echo "Testing..."

buid-image:
  stage: build-image
  image: 
    name: gcr.io/kaniko-project/executor:debug
    entrypoint: [""]
  script:
    - pwd
    - ls
    - mkdir -p /kaniko/.docker
    - |
      echo "{ \"auths\": { \"$DOCKER_REGISTRY_HOST\": { \"auth\": \"$(echo -n $DOCKER_REGISTRY_USER:$DOCKER_REGISTRY_PASSWORD | base64 -w0)\" } } }" > /kaniko/.docker/config.json
    - cat /kaniko/.docker/config.json
    - /kaniko/executor --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile --destination=$DOCKER_REGISTRY_USER/$CI_PROJECT_NAME:$VERSION 

deploy:
  stage: deploy
  script:    
    - apk add kubectl helm
    - cd helm
    - kubectl create namespace $KUBERNETES_NAMESPACE --dry-run=client -o yaml | kubectl apply -f -
    - kubectl create secret docker-registry regcred -n $KUBERNETES_NAMESPACE --docker-server=$DOCKER_REGISTRY_HOST --docker-username=$DOCKER_REGISTRY_USER --docker-password=$DOCKER_REGISTRY_PASSWORD --dry-run=client -o yaml | kubectl apply -f -
    - helm upgrade --install $CI_PROJECT_NAME . --set image=$DOCKER_REGISTRY_USER/$CI_PROJECT_NAME:$VERSION

Si lo analizáis bien veréis que tenemos un script por stage, en el vídeo los he comentado.

Subir código y ver como se despliega

Con todo ahora ya solo nos queda añadir todos los ficheros al repo(Cuidado porque el .gitlab-ci.yml se tiene que especificar al ser oculto), hacer el commit y hacer el push para ver los resultados:

git add *
git add .gitlab-ci.yml

git commit -m "Primer commit"

git push

Y el resto ya es historia :D

Tutorial de punteros en Go

Albert Coronado — Mon, 24 Apr 2023 13:09:03 +0000

Este artículo está basado en el vídeo de la semana pasada sobre punteros en Go, aquí lo tendréis explicado con texto y acceso al código fuente(Así no tenéis que copiar de la pantalla, que os conozco :D). Si os resulta útil podéis darle a like, compartir, comentar, etc.

Introducción a los punteros

Los punteros, a diferencia de las variables donde el compilador reserva una posición de memoria para almacenar información, estos no tienen una posición de memoria reservada y pueden apuntar a la posición de memoria que les indiquemos.

Por ejemplo, en el siguiente ejemplo declaramos una variable llamada 'v' con el valor '4', seguidamente imprimimos por pantalla el valor de la variable y su posición de memoria(Con el símbolo '&' accedemos a la posición de memoria de una variable). Después, tenemos declarado el puntero 'p' al que apuntamos a la posición de memoria de la variable 'v' y le asignamos otro valor(Con el símbolo '*' accedemos al valor de la posición de memoria de un puntero).

var v int = 4
var p *int

fmt.Printf( "El valor de v es %d \n", v )
fmt.Printf( "La posición de memória de v es %v \n", &v )

p = &v
*p = 8

fmt.Printf( "El valor de p es %d \n", *p )
fmt.Printf( "La posición de memória de p es %v \n", p )

Paso de parámetros por valor o referencia

Una de las aplicaciones del uso de punteros es pasar variables a las funciones por referencia. Cuando pasamos un parámetro a una función por 'valor' el compilador lo que hace es reservar una posición de memoria para ese parámetro y copiarle el valor. Si lo hacemos por 'referencia', es decir, usando punteros estamos usando la misma posición de memoria y, por lo tanto, es mucho más rápido.

Hemos hecho un ejemplo de esto en el vídeo:

package main

import "fmt"

func main() {
    var v int = 4
    var p *int

    p = &v
    *p = 8

    IncValor( v )
    IncReferencia( &v )

    fmt.Printf( "El valor de v es %d \n", v )
    fmt.Printf( "La posición de memória de v es %v \n", &v )

        fmt.Printf( "El valor de p es %d \n", *p )
        fmt.Printf( "La posición de memória de p es %v \n", p )
}

func IncValor( v int  ) {
    v++
    fmt.Printf( "El valor incrementado(Por valor) es %d \n", v )
    }

func IncReferencia( v *int ) {
    *v++
    fmt.Printf( "El valor incrementado(Por referencia) es %d \n", *v )
    }

Listas con punteros

Otra aplicación de los punteros donde se demuestra su potencia es creando estructuras de datos. En el vídeo hemos creado un CRUD(Create-Read-Update-Delete) de clientes:

package main

import "fmt"

type Cliente struct {
    nombre string
    telefono string
    next *Cliente
}

var primerCliente *Cliente

func main() {
    AddCliente( "Pepe", "555 555 555" )
        AddCliente( "Juan", "555 555 556" )
        AddCliente( "Rodrigo", "555 555 557" )
        AddCliente( "David", "555 555 558" )

    ListaClientes()

    var cliente *Cliente = GetCliente(2)
    (*cliente).nombre = "Albert"

    fmt.Printf( "\nClientes Update\n" )
    ListaClientes()

    DeleteCliente( 2 )
    fmt.Printf( "\nClientes Delete\n" )
        ListaClientes()
    }

func AddCliente(nombre string, telefono string) {
    var cliente = Cliente{
        nombre:   nombre,
        telefono: telefono,
        next:     nil,
    }

    if primerCliente == nil {
        primerCliente = &cliente

        return
    }

    var nextCliente *Cliente = primerCliente
    for nextCliente.next != nil {
        nextCliente = nextCliente.next
    }

    nextCliente.next = &cliente
}

func ListaClientes() {
    if primerCliente == nil {
        return
    }

    var nextCliente *Cliente = primerCliente
    for nextCliente.next != nil {
        fmt.Printf("Nombre: %s Teléfono: %s \n", nextCliente.nombre, nextCliente.telefono)

        nextCliente = nextCliente.next
    }

    fmt.Printf("Nombre: %s Teléfono: %s \n", nextCliente.nombre, nextCliente.telefono)
}

func GetCliente(pos int) *Cliente {
    if primerCliente == nil {
        return nil
    }

    var nextCliente *Cliente = primerCliente
    i := 0
    for i < pos && nextCliente.next != nil {
        nextCliente = nextCliente.next
        i++
    }

    if i != pos {
        return nil
    }

    return nextCliente
}

func DeleteCliente(pos int) {
    if primerCliente == nil {
        return
    }

    if pos == 0 {
        if primerCliente.next == nil {
            primerCliente = nil

            return
        }

        primerCliente = primerCliente.next
        return
    }

    var cliente *Cliente = GetCliente(pos)
    var previo *Cliente = GetCliente(pos - 1)
    if cliente == nil || previo == nil {
        return
    }

    previo.next = cliente.next
}

En el ejemplo, hemos creado una estructura para almacenar clientes donde también tenemos un puntero al siguiente cliente. De esta manera podemos recorrer los clientes desde el primero hasta que encontremos el último(El que el puntero 'next' tiene valor None) y para eliminar uno de la lista simplemente hay que quitarlo de la cadena(En el caso de Go, a diferencia de C, no hace falta liberar la memoria porque lo hace solo con el recolector de basura).

Podemos optimizar el ejemplo para distintos casos de uso: Con dos punteros(Uno para next y otro para prev y así recorrer la lista en dos direcciones), con otro puntero que apunte al final de la lista, con otro puntero en la mitad de la lista, con punteros para ordenar los registros usando un índice, etc.

En fin, espero que hayáis disfrutado del contenido y os haya resultado útil. La mejor manera de colaborar es dándole a like, comentar y compartir, a ver si hacemos que esta red social se llene de contenido hispano hablante...

Python Crash Course, de 0 a 100 con Python

Albert Coronado — Tue, 11 Apr 2023 13:50:35 +0000

Hoy os dejo todo el código del videotutorial de Python en esta comunidad. Así que si me queréis seguir, comentar, darle a like, etc. me haréis un favor(Tanto aquí como en Youtube, Linkedin, etc.)(Sí, soy mu pesao).

Estructuras de datos

Lo primero que hemos hecho ha sido trabajar con variables y estructuras de datos. Python tiene los típicos tipos básicos Integer, Float, Boolean y Strings pero donde realmente destaca es por su soporte nativo a listas, tuplas y diccionarios:

mylist = [ "java", "go", "php", "python", "nodejs" ]

print( "" )
print( "Listas" )
print( "===============================================================" )
print( "mylist: %s" % mylist )
print( "Intervalo 1 a 4: %s" % mylist[1:4] )
print( "Intervalo 1 al final: %s" % mylist[1:] )
print( "Intervalo posición 2 empezando por atrás al final: %s" % mylist[-2:] )

mylist.append( "rust" )
mylist.remove( "php" )
mylist.append( 4 )

print( "Añado 'rust', quito 'php', añado 4: %s" %mylist )

# Las tuplas son como las listas pero inmutables. Su principal ventaja es el poco espacio que ocupan en memória

mytupla = ( "java", "go", "php", "python", "nodejs" )

print( "" )
print( "Tuplas" )
print( "===============================================================" )
print( "mytupla: {0}".format(mytupla) )

# Diccionarios

print( "" )
print( "Diccionarios" )
print( "===============================================================" )
mydict = { "hello": "world", "mylist": mylist, "mytupla": mytupla }

print( "mydict: {0}".format(mydict) )
print( "Valor de 'hello': {0}({1})".format(mydict['hello'], type(mydict['hello'])) )

Estructuras de control: condicionales y bucles

Después de ver las estructuras de datos hemos visto como crear condicionales y bucles:

# bucles
print( "" )
print( "Bucles" )
print( "===============================================================" )

for x in mydict:
    print( "keys: {0}".format(x) )

for x, y in mydict.items():
    print( "{0} = {1}".format(x, y) )    

for x in mydict.values():
    print( "values: {0}".format(x) )    

for x in range(1,5):
    print( "Rango: {0}".format(x) )    

count = 0
while count < 5:
    print( "Condición: {0}".format(count) )
    count += 1

# condicionales
print( "" )
print( "Condicionales" )
print( "===============================================================" )

for x in mytupla:
    print( "Procesando: {0}".format(x) )

    if x == "go":
        print( " Es Go!!!!!!!!!!!!!!!!!!!!!!!!!" )
    else:
        print( " No es go" )

Estructuración del código: Funciones, lambdas y classes

# Funciones y lambdas
def my_function( myparam ):
    print( "El parámetro de mi función es: {0}".format( myparam ) )

    return "ok"

print( "" )
print( "funciones" )
print( "===============================================================" )
my_function( mylist )

print( "" )
print( "lambdas" )
print( "===============================================================" )
mylamda = lambda x,y:x+y
print( "El resultado de 2+5={0}".format( mylamda(2,5) ) )

# Classes
print( "" )
print( "Condicionales" )
print( "===============================================================" )

class Vehiculo:
    def __init__(self, ruedas):
        self.ruedas = ruedas

coche = Vehiculo( 4 )
print( coche )
print( vars(coche) )

Módulos

Los módulos nos permiten organizar el código y para ilustrar su funcionamiento hemos creado un fichero llamado 'mymodule.py' con una variable y una función:

mymodulevar = { "customer_id":12, "total": 15000 }

def mymodulefunc():
    print( "Module func" )

Después hemos creado un segundo fichero en python y hemos hecho uso de sus recursos:

import mymodule

mymodule.mymodulefunc()

x = dir(mymodule)

print(x)

Bonus Track: Script Ejecutable

Finalmente, hemos visto como podíamos crear un script ejecutable con python simplemente creando un archivo y añadiendo en su cabecera #!/usr/bin/env python3 y dándole permisos de ejecución con chmod +x myfichero.

También hemos usado el módulo 'argparse' que nos ofrece el API de Python para parsear argumentos. El código del script es el siguiente:

#!/usr/bin/env python3
import argparse

parser = argparse.ArgumentParser(description="PaaS deployment tool.", formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-r', '--repository', required=True, help="Gitlab repository URL.") 
parser.add_argument('-e', '--environment', choices=["dev","pre", "pro"], default="dev", required=False, help="Environment.") 
parser.add_argument('action', nargs="?", choices=["deploy"], default="deploy", help="Openshift project name.") 

args = vars( parser.parse_args() )

print( "" )
print( "Argumentos:" )
print( "  %s" % args )
print( "" )

¡Esto es todo amigos! Espero que lo disfrutéis.

Older versions of Docker over Docker Machine

Albert Coronado — Mon, 20 Dec 2021 10:46:58 +0000

Sometimes we may need use different versions of Docker on our machine. We may interest this functionality in order to support older versions of Docker on our developments. In my case, I needed an older version of Docker because new versions of Docker require ‘Content-Length’ header to download images from a repository(The rest is another history).

We may deploy any versions of Docker using Docker Machine just adding the '--virtualbox-boot2docker-url' parameter:

docker-machine create -d virtualbox --virtualbox-boot2docker-url https://github.com/boot2docker/boot2docker/releases/download/v18.09.8/boot2docker.iso ics2

I hope help anyone with this tip.