Thierry  Perret

Thierry Perret

1657351860

Les 5 Meilleurs Conseils Pour Les Débutants En Développement Web

L'ère moderne du développement Web est fascinante. De nombreux frameworks et bibliothèques pour rester productifs. Il existe des milliers de ressources de qualité à lire et à apprendre. Outre la pléthore de livres, de blogs et de cours, les développeurs Web ont Google, YouTube, Twitter, LinkedIn et Stackoverflow comme meilleurs amis. Cependant, vous pouvez trouver cela un peu écrasant en tant que débutant.

Si vous débutez dans le développement Web, j'ai quelques éléments à partager avec vous. Après avoir passé plus d'une décennie sur diverses technologies et piles Web, je suggère de me concentrer sur ces cinq points en tant que débutant.

1. Apprendre Git et GitHub

Surpris? Oui, le premier concerne l'apprentissage de Git ! Apprenez les commandes et le workflow Git afin de mieux gérer le code source de votre projet. Cela vous aidera également à collaborer avec de nombreux autres projets qui vous intéressent sur Git.

Au minimum, vous devez savoir ce qui suit,

  • Comment initier un dépôt Git ?
  • Comment mettre en scène/annuler la mise en scène de vos modifications de code ?
  • Comment commiter et amender un commit ? Quelles sont les normes pour un bon message de commit ?
  • Comment pousser vos modifications vers le dépôt ?
  • Comment fusionner une autre branche à votre branche ?
  • Comment résoudre les conflits de fusion ?

En plus des commandes Git, concentrez-vous également sur la connaissance de GitHub et Workflows . Tu dois savoir,

  • Comment créer et gérer des référentiels ?
  • Comment créer un dépôt et y contribuer ?
  • Comment gérer les succursales ?
  • Comment créer et gérer des Pull Requests ?

Plus vous utilisez GitHub pour gérer publiquement vos projets, plus vous avez la possibilité de collaborer, de partager et d'apprendre. Je recommanderais fortement un profil GitHub actif dès le début de votre parcours de développement Web.

Si vous souhaitez en savoir plus sur la façon d'augmenter les engagements sur vos référentiels GitHub publics, voici quelques conseils pour vous aider,

Guide GitHub Repo - Comment augmenter l'engagement sur vos référentiels GitHub publics GitHub est une collection d'outils Web qui vous aide à travailler avec le contrôle de version et les méthodologies Git. Avec l'aide de GitHub, vous pouvez créer, ma...www.freecodecamp.org

2. Apprenez les fondamentaux. Voici pourquoi et comment

En tant que débutant, concentrez-vous sur la compréhension et la pratique des fondamentaux. Par exemple, si vous avez commencé avec le développement Web basé sur JavaScript, concentrez-vous sur l'apprentissage de Plain JavaScript (aka Vanilla JavaScript), HTML5 et CSS. Les frameworks et les bibliothèques sont remarquables, et nous ne pouvons pas bien évoluer sans eux. Cependant, cela aiderait si vous vous concentriez bien, vraiment bien sur les fondamentaux.

Voici un Tweet qui a déclenché d'excellentes discussions sous forme de commentaires. Vous voudrez peut-être jeter un œil quand vous aurez le temps.

 

Permettez-moi maintenant de me concentrer sur la façon de continuer à apprendre les fondamentaux lorsque les frameworks et les bibliothèques sont si demandés. Planifiez des projets parallèles et soyez cohérent avec eux. Vous devrez peut-être commencer à travailler sur une bibliothèque ou un framework immédiatement parce que votre travail/rôle l'exige. Mais, n'arrêtez pas de faire des projets parallèles en utilisant les fondamentaux.

Voici quelques idées de projets utilisant JavaScript, HTML et CSS,

Colorify : colorez un cercle (un div) avec différents clics de bouton (rouge, vert, bleu, etc.).

Objectifs d'apprentissage : disposition des boutons, style de base de div avec rayon de bordure et centrage, gestionnaires de clics, manipulation du DOM pour définir des valeurs.

Couleurs aléatoires : choisissez une couleur aléatoire et définissez-la comme couleur d'arrière-plan d'une page.

Objectifs d'apprentissage : Presque similaires aux tableaux ci-dessus plus et en choisissant un élément aléatoire à partir de celui-ci. Vous pouvez également improviser celui-ci avec des méthodes de tableau comme fill() et autres.

Force du mot de passe : Vérifiez la force d'un mot de passe (faible, ok, fort).

Objectifs d'apprentissage : styliser une boîte de mot de passe, gérer les événements clés.

Knock Knock : Créez trois portes avec du CSS et des images. Cliquer sur chacune des portes révèle quelques surprises.

Objectifs d'apprentissage : animation CSS, manipulation DOM, CSS de base, UX.

Rock Paper Scissors : Un jeu très populaire de minimum 2 joueurs.

Objectifs d'apprentissage : Faire preuve de créativité dans la construction d'une bonne UX, mise en page, ramification logique.

Déplacer la balle : Déplacez la balle (ou tout autre objet) en utilisant les connaissances de mise en page. Comme en utilisant les propriétés CSS Flexbox, vous pouvez déplacer l'objet à divers endroits dans l'interface utilisateur.

Objectifs d'apprentissage : Mise en page CSS et FlexBox, JavaScript DOM dans l'application du style.

Tick ​​Tac Toe : Nous savons tous ce que c'est. Un simple jeu de X et O.

Objectifs d'apprentissage : mise en page de l'interface utilisateur, logiques JavaScript. De même, vous pouvez créer une calculatrice Web.

Formulaire d'enquête : un ensemble de champs de saisie dans un formulaire acceptant les entrées de l'utilisateur. La soumission de l'enquête s'effectue en cliquant sur un bouton de soumission.

Objectifs d'apprentissage : formulaires HTML, gestion des formulaires, action de formulaire, alignement de la mise en page à l'aide de CSS.

Liste Pokemon : Faites un appel API pour obtenir les informations Pokemon et listez-les comme vous le souhaitez. Vous pouvez étendre le même projet pour ajouter une fonctionnalité de recherche/trouver des pokémons.

Objectifs d'apprentissage : mise en page CSS, appel d'API à l'aide de fetch.

Animalerie en ligne : projet un peu plus avancé pour créer une animalerie en ligne. Listez les détails de l'animal avec des images et d'autres descriptions comme le nom, le type, le prix. Autorisez les utilisateurs à ajouter les animaux de compagnie à un panier et à payer avec un faux paiement.

Objectifs d'apprentissage : Mise en page CSS, Gestion des données JSON d'un magasin local, API Web de stockage local, API Web de paiement JavaScript, Application à page unique.

Je peux continuer, mais cela fera de cet article une taille géante. Si vous souhaitez discuter de l'un de ces projets ou de toute autre idée de projet, mes DM sont ouverts sur Twitter . N'hésitez pas à nous contacter.

3. Ne soyez pas un développeur "Framework Biased"

Citons les 5 meilleurs frameworks/bibliothèques de développement Web basés sur JavaScript. Il y a de fortes chances que j'ai déjà couvert votre préféré.

  • Réagir
  • Angulaire
  • Vue
  • Svelte
  • Next.js (Eh bien, basé sur la réaction mais mérite une mention séparée)

Côté CSS ?

  • Vent arrière
  • Amorcer
  • Bulma
  • Se concrétiser
  • Fondation

Vous pouvez en aimer un ou plusieurs, mais ne soyez pas biaisé à ce sujet. Par biaisé, je veux dire que vous construisez tôt votre opinion que "c'est le cadre/la bibliothèque" que vous devriez toujours utiliser. Parfois, les préjugés peuvent également forcer les autres à partager votre opinion.

En tant que débutant, soyez ouvert à de nouveaux apprentissages. Choisissez et apprenez les choses qui se présentent sur votre chemin. Vous aurez toujours vos favoris, mais cela ne devrait pas être votre façon d'en essayer de nouveaux. Être flexible vous permettra d'essayer et de contribuer à divers projets open source dès les premières étapes de votre carrière.

4. Prenez des notes sur vos progrès et votre apprentissage

Ce n'est pas excitant (du moins par rapport au codage) de documenter les choses. Cependant, c'est une pièce précieuse avec un retour sur investissement (ROI) élevé. Je suggérerais de documenter à la fois le progrès (le voyage) et l'apprentissage.

Un moyen efficace de documenter les progrès est de participer à un défi auto-investi comme #100daysofcode sur Twitter et de faire savoir au monde comment vous progressez. Cela aide également à se connecter avec des personnes partageant les mêmes idées, à obtenir des commentaires et à se motiver pour continuer.

Vous devez également documenter votre apprentissage. Sous quelque forme que cela vous convienne. Je suggérerais de prendre des notes au format Markdown (MD) car cela vous permet de refaire plus facilement surface vos notes approximatives sous forme d'article de blog.

 

Prendre des notes et les revoir de temps en temps, c'est comme renouveler son apprentissage à sa guise. J'espère que vous commencez cela dès maintenant, et si vous le faites déjà, SUPER !!!

5. Pratique, pratique, ....., pratique

Il n'y a pas d'alternative à Pratiquer ce que vous apprenez pour mieux l'apprendre. Il en va de même pour le développement Web. Vous devez allouer du temps à la pratique. Une connaissance théorique ne fait que quelques kilomètres mais, la pratique fait un long chemin !

Voici mon principe en 5 points pour la pratique logique de tout nouveau concept,

  1. Choisissez un sujet à apprendre. Si vous pouvez le diviser en sujets plus petits, c'est très bien.
  2. Lisez à ce sujet à partir de toutes vos sources préférées. S'il existe un didacticiel de suivi (étape par étape) pour vous entraîner, faites-le.
  3. Créez votre exemple à partir de l'apprentissage. Le plus petit est le meilleur. Il pourrait également y avoir plusieurs exemples.
  4. Créez des projets GitHub pour chacun d'entre eux. Commencez à mettre en œuvre.
  5. Est resté coincé? Revisitez le sujet, apprenez, continuez le projet pour le compléter. Passez au sujet suivant.

Conclusion

Le développement Web est un domaine technologique fascinant. Vous l'apprécierez autant que vous explorerez, apprendrez et créerez des choses. J'espère que les conseils partagés dans l'article vous aideront. Veuillez commenter ci-dessous pour me le faire savoir. Aussi, si vous avez des questions, n'hésitez pas à les poser. Veuillez aimer/partager cet article afin qu'il atteigne également d'autres personnes. L'illustration du développeur dans l'image de couverture utilise une illustration gratuite de subpng .

Lien : https://blog.greenroots.info/5-tips-for-beginners-to-web-development

#webdev #html #css #javascript

What is GEEK

Buddha Community

Les 5 Meilleurs Conseils Pour Les Débutants En Développement Web
Thierry  Perret

Thierry Perret

1657351860

Les 5 Meilleurs Conseils Pour Les Débutants En Développement Web

L'ère moderne du développement Web est fascinante. De nombreux frameworks et bibliothèques pour rester productifs. Il existe des milliers de ressources de qualité à lire et à apprendre. Outre la pléthore de livres, de blogs et de cours, les développeurs Web ont Google, YouTube, Twitter, LinkedIn et Stackoverflow comme meilleurs amis. Cependant, vous pouvez trouver cela un peu écrasant en tant que débutant.

Si vous débutez dans le développement Web, j'ai quelques éléments à partager avec vous. Après avoir passé plus d'une décennie sur diverses technologies et piles Web, je suggère de me concentrer sur ces cinq points en tant que débutant.

1. Apprendre Git et GitHub

Surpris? Oui, le premier concerne l'apprentissage de Git ! Apprenez les commandes et le workflow Git afin de mieux gérer le code source de votre projet. Cela vous aidera également à collaborer avec de nombreux autres projets qui vous intéressent sur Git.

Au minimum, vous devez savoir ce qui suit,

  • Comment initier un dépôt Git ?
  • Comment mettre en scène/annuler la mise en scène de vos modifications de code ?
  • Comment commiter et amender un commit ? Quelles sont les normes pour un bon message de commit ?
  • Comment pousser vos modifications vers le dépôt ?
  • Comment fusionner une autre branche à votre branche ?
  • Comment résoudre les conflits de fusion ?

En plus des commandes Git, concentrez-vous également sur la connaissance de GitHub et Workflows . Tu dois savoir,

  • Comment créer et gérer des référentiels ?
  • Comment créer un dépôt et y contribuer ?
  • Comment gérer les succursales ?
  • Comment créer et gérer des Pull Requests ?

Plus vous utilisez GitHub pour gérer publiquement vos projets, plus vous avez la possibilité de collaborer, de partager et d'apprendre. Je recommanderais fortement un profil GitHub actif dès le début de votre parcours de développement Web.

Si vous souhaitez en savoir plus sur la façon d'augmenter les engagements sur vos référentiels GitHub publics, voici quelques conseils pour vous aider,

Guide GitHub Repo - Comment augmenter l'engagement sur vos référentiels GitHub publics GitHub est une collection d'outils Web qui vous aide à travailler avec le contrôle de version et les méthodologies Git. Avec l'aide de GitHub, vous pouvez créer, ma...www.freecodecamp.org

2. Apprenez les fondamentaux. Voici pourquoi et comment

En tant que débutant, concentrez-vous sur la compréhension et la pratique des fondamentaux. Par exemple, si vous avez commencé avec le développement Web basé sur JavaScript, concentrez-vous sur l'apprentissage de Plain JavaScript (aka Vanilla JavaScript), HTML5 et CSS. Les frameworks et les bibliothèques sont remarquables, et nous ne pouvons pas bien évoluer sans eux. Cependant, cela aiderait si vous vous concentriez bien, vraiment bien sur les fondamentaux.

Voici un Tweet qui a déclenché d'excellentes discussions sous forme de commentaires. Vous voudrez peut-être jeter un œil quand vous aurez le temps.

 

Permettez-moi maintenant de me concentrer sur la façon de continuer à apprendre les fondamentaux lorsque les frameworks et les bibliothèques sont si demandés. Planifiez des projets parallèles et soyez cohérent avec eux. Vous devrez peut-être commencer à travailler sur une bibliothèque ou un framework immédiatement parce que votre travail/rôle l'exige. Mais, n'arrêtez pas de faire des projets parallèles en utilisant les fondamentaux.

Voici quelques idées de projets utilisant JavaScript, HTML et CSS,

Colorify : colorez un cercle (un div) avec différents clics de bouton (rouge, vert, bleu, etc.).

Objectifs d'apprentissage : disposition des boutons, style de base de div avec rayon de bordure et centrage, gestionnaires de clics, manipulation du DOM pour définir des valeurs.

Couleurs aléatoires : choisissez une couleur aléatoire et définissez-la comme couleur d'arrière-plan d'une page.

Objectifs d'apprentissage : Presque similaires aux tableaux ci-dessus plus et en choisissant un élément aléatoire à partir de celui-ci. Vous pouvez également improviser celui-ci avec des méthodes de tableau comme fill() et autres.

Force du mot de passe : Vérifiez la force d'un mot de passe (faible, ok, fort).

Objectifs d'apprentissage : styliser une boîte de mot de passe, gérer les événements clés.

Knock Knock : Créez trois portes avec du CSS et des images. Cliquer sur chacune des portes révèle quelques surprises.

Objectifs d'apprentissage : animation CSS, manipulation DOM, CSS de base, UX.

Rock Paper Scissors : Un jeu très populaire de minimum 2 joueurs.

Objectifs d'apprentissage : Faire preuve de créativité dans la construction d'une bonne UX, mise en page, ramification logique.

Déplacer la balle : Déplacez la balle (ou tout autre objet) en utilisant les connaissances de mise en page. Comme en utilisant les propriétés CSS Flexbox, vous pouvez déplacer l'objet à divers endroits dans l'interface utilisateur.

Objectifs d'apprentissage : Mise en page CSS et FlexBox, JavaScript DOM dans l'application du style.

Tick ​​Tac Toe : Nous savons tous ce que c'est. Un simple jeu de X et O.

Objectifs d'apprentissage : mise en page de l'interface utilisateur, logiques JavaScript. De même, vous pouvez créer une calculatrice Web.

Formulaire d'enquête : un ensemble de champs de saisie dans un formulaire acceptant les entrées de l'utilisateur. La soumission de l'enquête s'effectue en cliquant sur un bouton de soumission.

Objectifs d'apprentissage : formulaires HTML, gestion des formulaires, action de formulaire, alignement de la mise en page à l'aide de CSS.

Liste Pokemon : Faites un appel API pour obtenir les informations Pokemon et listez-les comme vous le souhaitez. Vous pouvez étendre le même projet pour ajouter une fonctionnalité de recherche/trouver des pokémons.

Objectifs d'apprentissage : mise en page CSS, appel d'API à l'aide de fetch.

Animalerie en ligne : projet un peu plus avancé pour créer une animalerie en ligne. Listez les détails de l'animal avec des images et d'autres descriptions comme le nom, le type, le prix. Autorisez les utilisateurs à ajouter les animaux de compagnie à un panier et à payer avec un faux paiement.

Objectifs d'apprentissage : Mise en page CSS, Gestion des données JSON d'un magasin local, API Web de stockage local, API Web de paiement JavaScript, Application à page unique.

Je peux continuer, mais cela fera de cet article une taille géante. Si vous souhaitez discuter de l'un de ces projets ou de toute autre idée de projet, mes DM sont ouverts sur Twitter . N'hésitez pas à nous contacter.

3. Ne soyez pas un développeur "Framework Biased"

Citons les 5 meilleurs frameworks/bibliothèques de développement Web basés sur JavaScript. Il y a de fortes chances que j'ai déjà couvert votre préféré.

  • Réagir
  • Angulaire
  • Vue
  • Svelte
  • Next.js (Eh bien, basé sur la réaction mais mérite une mention séparée)

Côté CSS ?

  • Vent arrière
  • Amorcer
  • Bulma
  • Se concrétiser
  • Fondation

Vous pouvez en aimer un ou plusieurs, mais ne soyez pas biaisé à ce sujet. Par biaisé, je veux dire que vous construisez tôt votre opinion que "c'est le cadre/la bibliothèque" que vous devriez toujours utiliser. Parfois, les préjugés peuvent également forcer les autres à partager votre opinion.

En tant que débutant, soyez ouvert à de nouveaux apprentissages. Choisissez et apprenez les choses qui se présentent sur votre chemin. Vous aurez toujours vos favoris, mais cela ne devrait pas être votre façon d'en essayer de nouveaux. Être flexible vous permettra d'essayer et de contribuer à divers projets open source dès les premières étapes de votre carrière.

4. Prenez des notes sur vos progrès et votre apprentissage

Ce n'est pas excitant (du moins par rapport au codage) de documenter les choses. Cependant, c'est une pièce précieuse avec un retour sur investissement (ROI) élevé. Je suggérerais de documenter à la fois le progrès (le voyage) et l'apprentissage.

Un moyen efficace de documenter les progrès est de participer à un défi auto-investi comme #100daysofcode sur Twitter et de faire savoir au monde comment vous progressez. Cela aide également à se connecter avec des personnes partageant les mêmes idées, à obtenir des commentaires et à se motiver pour continuer.

Vous devez également documenter votre apprentissage. Sous quelque forme que cela vous convienne. Je suggérerais de prendre des notes au format Markdown (MD) car cela vous permet de refaire plus facilement surface vos notes approximatives sous forme d'article de blog.

 

Prendre des notes et les revoir de temps en temps, c'est comme renouveler son apprentissage à sa guise. J'espère que vous commencez cela dès maintenant, et si vous le faites déjà, SUPER !!!

5. Pratique, pratique, ....., pratique

Il n'y a pas d'alternative à Pratiquer ce que vous apprenez pour mieux l'apprendre. Il en va de même pour le développement Web. Vous devez allouer du temps à la pratique. Une connaissance théorique ne fait que quelques kilomètres mais, la pratique fait un long chemin !

Voici mon principe en 5 points pour la pratique logique de tout nouveau concept,

  1. Choisissez un sujet à apprendre. Si vous pouvez le diviser en sujets plus petits, c'est très bien.
  2. Lisez à ce sujet à partir de toutes vos sources préférées. S'il existe un didacticiel de suivi (étape par étape) pour vous entraîner, faites-le.
  3. Créez votre exemple à partir de l'apprentissage. Le plus petit est le meilleur. Il pourrait également y avoir plusieurs exemples.
  4. Créez des projets GitHub pour chacun d'entre eux. Commencez à mettre en œuvre.
  5. Est resté coincé? Revisitez le sujet, apprenez, continuez le projet pour le compléter. Passez au sujet suivant.

Conclusion

Le développement Web est un domaine technologique fascinant. Vous l'apprécierez autant que vous explorerez, apprendrez et créerez des choses. J'espère que les conseils partagés dans l'article vous aideront. Veuillez commenter ci-dessous pour me le faire savoir. Aussi, si vous avez des questions, n'hésitez pas à les poser. Veuillez aimer/partager cet article afin qu'il atteigne également d'autres personnes. L'illustration du développeur dans l'image de couverture utilise une illustration gratuite de subpng .

Lien : https://blog.greenroots.info/5-tips-for-beginners-to-web-development

#webdev #html #css #javascript

Evolution in Web Design: A Case Study of 25 Years - Prismetric

The term web design simply encompasses a design process related to the front-end design of website that includes writing mark-up. Creative web design has a considerable impact on your perceived business credibility and quality. It taps onto the broader scopes of web development services.

Web designing is identified as a critical factor for the success of websites and eCommerce. The internet has completely changed the way businesses and brands operate. Web design and web development go hand-in-hand and the need for a professional web design and development company, offering a blend of creative designs and user-centric elements at an affordable rate, is growing at a significant rate.

In this blog, we have focused on the different areas of designing a website that covers all the trends, tools, and techniques coming up with time.

Web design
In 2020 itself, the number of smartphone users across the globe stands at 6.95 billion, with experts suggesting a high rise of 17.75 billion by 2024. On the other hand, the percentage of Gen Z web and internet users worldwide is up to 98%. This is not just a huge market but a ginormous one to boost your business and grow your presence online.

Web Design History
At a huge particle physics laboratory, CERN in Switzerland, the son of computer scientist Barner Lee published the first-ever website on August 6, 1991. He is not only the first web designer but also the creator of HTML (HyperText Markup Language). The worldwide web persisted and after two years, the world’s first search engine was born. This was just the beginning.

Evolution of Web Design over the years
With the release of the Internet web browser and Windows 95 in 1995, most trading companies at that time saw innumerable possibilities of instant worldwide information and public sharing of websites to increase their sales. This led to the prospect of eCommerce and worldwide group communications.

The next few years saw a soaring launch of the now-so-famous websites such as Yahoo, Amazon, eBay, Google, and substantially more. In 2004, by the time Facebook was launched, there were more than 50 million websites online.

Then came the era of Google, the ruler of all search engines introducing us to search engine optimization (SEO) and businesses sought their ways to improve their ranks. The world turned more towards mobile web experiences and responsive mobile-friendly web designs became requisite.

Let’s take a deep look at the evolution of illustrious brands to have a profound understanding of web design.

Here is a retrospection of a few widely acclaimed brands over the years.

Netflix
From a simple idea of renting DVDs online to a multi-billion-dollar business, saying that Netflix has come a long way is an understatement. A company that has sent shockwaves across Hollywood in the form of content delivery. Abundantly, Netflix (NFLX) is responsible for the rise in streaming services across 190 countries and meaningful changes in the entertainment industry.

1997-2000

The idea of Netflix was born when Reed Hastings and Marc Randolph decided to rent DVDs by mail. With 925 titles and a pay-per-rental model, Netflix.com debuts the first DVD rental and sales site with all novel features. It offered unlimited rentals without due dates or monthly rental limitations with a personalized movie recommendation system.

Netflix 1997-2000

2001-2005

Announcing its initial public offering (IPO) under the NASDAQ ticker NFLX, Netflix reached over 1 million subscribers in the United States by introducing a profile feature in their influential website design along with a free trial allowing members to create lists and rate their favorite movies. The user experience was quite engaging with the categorization of content, recommendations based on history, search engine, and a queue of movies to watch.

Netflix 2001-2005 -2003

2006-2010

They then unleashed streaming and partnering with electronic brands such as blu-ray, Xbox, and set-top boxes so that users can watch series and films straight away. Later in 2010, they also launched their sophisticated website on mobile devices with its iconic red and black themed background.

Netflix 2006-2010 -2007

2011-2015

In 2013, an eye-tracking test revealed that the users didn’t focus on the details of the movie or show in the existing interface and were perplexed with the flow of information. Hence, the professional web designers simply shifted the text from the right side to the top of the screen. With Daredevil, an audio description feature was also launched for the visually impaired ones.

Netflix 2011-2015

2016-2020

These years, Netflix came with a plethora of new features for their modern website design such as AutoPay, snippets of trailers, recommendations categorized by genre, percentage based on user experience, upcoming shows, top 10 lists, etc. These web application features yielded better results in visual hierarchy and flow of information across the website.

Netflix 2016-2020

2021

With a sleek logo in their iconic red N, timeless black background with a ‘Watch anywhere, Cancel anytime’ the color, the combination, the statement, and the leading ott platform for top video streaming service Netflix has overgrown into a revolutionary lifestyle of Netflix and Chill.

Netflix 2021

Contunue to read: Evolution in Web Design: A Case Study of 25 Years

#web #web-design #web-design-development #web-design-case-study #web-design-history #web-development

Saul  Alaniz

Saul Alaniz

1659727800

Hangfire en ASP.NET Core 3.1

En este artículo, aprendamos sobre Hangfire en ASP.NET Core 3.1 y cómo integrarlo con sus aplicaciones principales. Una tarea de programación común a la que nos enfrentamos regularmente es ejecutar trabajos en segundo plano. Y ejecutar estos trabajos correctamente sin estropear su código no es una tarea fácil, pero tampoco es difícil. Solía ​​trabajar con los servicios de Windows para programar varias tareas dentro de mi aplicación C#. Luego, me encontré con esta biblioteca casi increíble: Hangfire, y nunca me fui.

Trabajos en segundo plano en ASP.NET Core

Básicamente, los trabajos en segundo plano son aquellos métodos o funciones que pueden tardar mucho tiempo en ejecutarse (cantidad de tiempo desconocida). Estos trabajos, si se ejecutan en el subproceso principal de nuestra aplicación, pueden o no bloquear la interacción del usuario y puede parecer que nuestra aplicación .NET Core se ha bloqueado y no responde. Esto es bastante crítico para las aplicaciones orientadas al cliente. Por lo tanto, tenemos trabajos en segundo plano, similares a los subprocesos múltiples, estos trabajos se ejecutan en otro subproceso, lo que hace que nuestra aplicación parezca bastante asíncrona.

También deberíamos tener la posibilidad de programarlos en un futuro cercano para que esté completamente automatizado. La vida de un desarrollador sería muy dura sin estas increíbles posibilidades.

¿Qué es Hangfire?

Hangfire es una biblioteca de código abierto que permite a los desarrolladores programar eventos en segundo plano con la mayor facilidad. Es una biblioteca altamente flexible que ofrece varias funciones necesarias para hacer que la tarea de programación de trabajos sea pan comido. Hangfire en ASP.NET Core es la única biblioteca que no puede perderse.

Integración de Hangfire en ASP.NET Core 3.1

Para este tutorial, tengamos un escenario específico para que podamos explicar Hangfire y su potencial completo. Digamos que estamos desarrollando una API que se encarga de enviar correos al Usuario para diferentes escenarios. Tiene más sentido explicar Hangfire de esta manera. Hangfire es una de las bibliotecas más fáciles de adaptar, pero también muy poderosa. Es uno de los paquetes que ayuda por completo a crear aplicaciones de forma asíncrona y desacoplada.

Como mencioné anteriormente, Hangfire usa una base de datos para almacenar los datos del trabajo. Usaremos la base de datos del servidor MSSQL en esta demostración. Hangfire crea automáticamente las tablas requeridas durante la primera ejecución.

Configuración del proyecto ASP.NET Core

Comenzaremos creando un nuevo proyecto ASP.NET Core con la plantilla API seleccionada. Ahora cree un controlador de API vacío. Llamémoslo HangfireController. Estoy usando Visual Studio 2019 Community como mi IDE y POSTMAN para probar las API.

Instalación de los paquetes Hangfire

Instalando el único paquete que necesitarías para configurar Hangfire.

Install-Package Hangfire

Configuración de Hangfire

Una vez que haya instalado el paquete, ahora estamos listos para configurarlo para que sea compatible con nuestra aplicación ASP.NET Core API. Este es un paso bastante sencillo, además, una vez que instale el paquete, se le mostrará un Léame rápido que le muestra el paso para completar la configuración.

Navigate to Startup.cs / ConfigureServices so that it looks like the below code snippet.
public void ConfigureServices(IServiceCollection services)
{
services.AddHangfire(x => x.UseSqlServerStorage("<connection string>"));
services.AddHangfireServer();
services.AddControllers();
}

Explicación.
Línea #3 Agrega el servicio Hangfire a nuestra aplicación. También hemos mencionado el almacenamiento que se utilizará, el servidor MSSQL, junto con la cadena/nombre de conexión.
La línea n.º 4 en realidad enciende el servidor Hangfire, que es responsable del procesamiento de trabajos.

Una vez hecho esto, vayamos al método Configurar y agregue la siguiente línea.

app.UseHangfireDashboard("/mydashboard");

Explicación.
Lo que hace esta línea es que nos permite acceder al panel de hangfire en nuestra aplicación ASP.NET Core. El tablero estará disponible yendo a /URL de mi tablero. Iniciemos la aplicación.

Esquema de la base de datos Hangfire

Cuando inicia su aplicación ASP.NET Core por el momento, Hangfire verifica si tiene un esquema de Hangfire asociado disponible en su base de datos. Si no, creará un montón de tablas para ti. Así es como se vería su base de datos.

hangfire dbschema Hangfire en ASP.NET Core 3.1 - Trabajos en segundo plano simplificados

Panel de Hangfire

Después de cargar la aplicación, vaya a <localhost>/mydashboard. Podrá ver el panel de control de Hangfire.

Hangfire en ASP.NET Core

Desde el tablero podrás monitorear los trabajos y sus estados. También le permite activar manualmente los trabajos disponibles. Esta es la característica ÚNICA que diferencia a Hangfire de otros programadores. Tablero incorporado. ¿Cuan genial es eso? La captura de pantalla anterior es la de la descripción general del panel. Exploremos también las otras pestañas.

Pestaña de trabajos.

Todos los trabajos que están disponibles en el almacén de datos (nuestro servidor MSSQL) se enumerarán aquí. Obtendrá una idea completa del estado de cada trabajo (En cola, Exitoso, Procesando, Fallido, etc.) en esta pantalla.

trabajos hangfire Hangfire en ASP.NET Core 3.1 - Trabajos en segundo plano simplificados

Pestaña Reintentos.

Los trabajos tienden a fallar de vez en cuando debido a factores externos. En nuestro caso, nuestra api intenta enviar un correo al usuario, pero hay un problema de conexión interna, lo que hace que el trabajo no se ejecute. Cuando falla un trabajo, Hangfire continúa intentándolo hasta que pasa. (configurable)

hangfire vuelve a intentar Hangfire en ASP.NET Core 3.1 - Trabajos en segundo plano simplificados

Pestaña de trabajos recurrentes.

¿Qué sucede si necesita enviar por correo el uso de su factura mensualmente? Esta es la característica principal de Hangfire, trabajos recurrentes. Esta pestaña le permite monitorear todos los trabajos configurados.

hangfire recurrente Hangfire en ASP.NET Core 3.1 - Trabajos en segundo plano simplificados

Pestaña Servidores.

Recuerde, al configurar Hangfire en la clase Startup.cs, lo hemos mencionado. services.AddHangfireServer().. Esta es la pestaña donde muestra todos los Hangfire Server activos. Estos servidores son responsables de procesar los trabajos. Digamos que no ha agregado los servicios. AddHangfireServer() en la clase de inicio, aún podría agregar trabajos Hangfire a la base de datos, pero no se ejecutarán hasta que inicie un servidor Hangfire.

servidor hangfire Hangfire en ASP.NET Core 3.1 - Trabajos en segundo plano simplificados

Protección del panel Hangfire

Esta es una característica bastante obvia. Dado que el tablero puede exponer datos muy confidenciales como nombres de métodos, valores de parámetros, ID de correo electrónico, es muy importante que protejamos/restringamos este punto final. Hangfire, listo para usar, hace que el tablero sea seguro al permitir solo solicitudes locales. Sin embargo, puede cambiar esto implementando su propia versión de IDashboardAuthorizationFilter . Si ya implementó la Autorización en su API, puede implementarla para Hangfire. Consulte estos pasos para asegurar el tablero.

Tipos de trabajo en Hangfire

Los trabajos en segundo plano en ASP.NET Core (o digamos cualquier tecnología) pueden ser de muchos tipos según los requisitos. Repasemos los tipos de trabajo disponibles con Hangfire con la implementación adecuada y la explicación en nuestro proyecto ASP.NET Core API. Vamos a codificar.

Despedir y olvidar trabajos

Los trabajos de disparar y olvidar se ejecutan  solo una vez  y casi  inmediatamente  después de la creación. Crearemos nuestro primer trabajo de fondo. Abre el controlador Hangfire que habíamos creado. Crearemos un punto final POST que dé la bienvenida a un usuario con un correo electrónico (idealmente). Añade estos códigos.

[HttpPost]
[Route("welcome")]
public IActionResult Welcome(string userName)
{
var jobId = BackgroundJob.Enqueue(() => SendWelcomeMail(userName));
return Ok($"Job Id {jobId} Completed. Welcome Mail Sent!");
}

public void SendWelcomeMail(string userName)
{
//Logic to Mail the user
Console.WriteLine($"Welcome to our application, {userName}");
}

Explicación.
La línea #5 almacena JobId en una variable. Puede ver que en realidad estamos agregando un trabajo en segundo plano representado por una función ficticia SendWelcomeMail. El JobId se vuelve a publicar más tarde en el Panel de control de Hangfire. Cree la aplicación y ejecútela. Vamos a probarlo con Postman.

hangfire faf postman Hangfire en ASP.NET Core 3.1 - Trabajos en segundo plano simplificados

Tenga en cuenta la URL y cómo estoy pasando el nombre de usuario al controlador. Una vez que lo ejecute, obtendrá nuestra respuesta requerida. “Id. de trabajo 2 completado. ¡Correo de bienvenida enviado!”. Ahora veamos el tablero de Hangfire.

hangfire faf dash Hangfire en ASP.NET Core 3.1 - Trabajos en segundo plano simplificados

En la pestaña Correcto, puede ver el recuento de trabajos completados. También puede ver los detalles de cada trabajo, similar a la captura de pantalla anterior. Todos los parámetros y nombres de funciones se exponen aquí. ¿Quiere volver a ejecutar este trabajo con los mismos parámetros? Presiona el botón Volver a poner en cola. Vuelve a agregar su trabajo en la cola para que Hangfire lo procese. Sucede casi de inmediato.

Trabajos retrasados

Ahora, qué pasa si queremos enviar un correo a un usuario, no inmediatamente, sino después de 10 minutos. En tales casos, utilizamos trabajos retrasados. Veamos su implementación, después de lo cual lo explicaré en detalle. En el mismo controlador, agregue estas líneas de código. Es bastante similar a la variante anterior, pero le introducimos un factor de retraso.

[HttpPost]
[Route("delayedWelcome")]
public IActionResult DelayedWelcome(string userName)
{
var jobId = BackgroundJob.Schedule(() => SendDelayedWelcomeMail(userName),TimeSpan.FromMinutes(2));
return Ok($"Job Id {jobId} Completed. Delayed Welcome Mail Sent!");
}

public void SendDelayedWelcomeMail(string userName)
{
//Logic to Mail the user
Console.WriteLine($"Welcome to our application, {userName}");
}

Explicación.
La línea #5 programó el trabajo en un período de tiempo definido, en nuestro caso son 2 minutos. Eso significa que nuestro trabajo se ejecutará 2 minutos después de que Postman haya llamado a la acción. Abramos Postman de nuevo y probemos.

hangfire retrasó al cartero Hangfire en ASP.NET Core 3.1 - Trabajos en segundo plano simplificados

Puede ver que recibimos la respuesta esperada de Postman. Ahora. vuelva rápidamente al Panel de control de Hangfire y haga clic en la pestaña Trabajos/programados. Diría que el trabajo se ejecutará en un minuto. Ahí estás para. Ha creado su primer trabajo programado usando Hangfire con facilidad.

hangfire retraso dash Hangfire en ASP.NET Core 3.1 - Trabajos en segundo plano simplificados

trabajos recurrentes

Nuestro Cliente tiene una suscripción a nuestro servicio. Obviamente, tendríamos que enviarle un recordatorio sobre el pago o la factura en sí. Esto llama la necesidad de un trabajo recurrente, donde puedo enviar correos electrónicos a mis clientes mensualmente. Esto es compatible con Hangfire mediante el programa CRON.
¿Qué es CRON? CRON es una utilidad basada en el tiempo que puede definir intervalos de tiempo. Veamos cómo lograr tal requisito.

[HttpPost]
[Route("invoice")]
public IActionResult Invoice(string userName)
{
RecurringJob.AddOrUpdate(() => SendInvoiceMail(userName), Cron.Monthly);
return Ok($"Recurring Job Scheduled. Invoice will be mailed Monthly for {userName}!");
}

public void SendInvoiceMail(string userName)
{
//Logic to Mail the user
Console.WriteLine($"Here is your invoice, {userName}");
}

La línea #5 establece claramente que estamos tratando de agregar/actualizar un trabajo recurrente, que llama a una función tantas veces como lo define el esquema CRON. Aquí enviaremos la factura al cliente mensualmente el primer día de cada mes. Ejecutemos la aplicación y cambiemos a Postman. Estoy ejecutando este código el 24 de mayo de 2020. Según nuestro requisito, este trabajo debe despedirse el 1 de junio de 2020, que es dentro de 7 días. Vamos a ver.

hangfire cartero recurrente Hangfire en ASP.NET Core 3.1 - Trabajos en segundo plano simplificados

Entonces, esto funcionó. Pasemos a Hangfire Dashboard y vayamos a la pestaña Trabajos recurrentes.

hangfire recurrente dash Hangfire en ASP.NET Core 3.1 - Trabajos en segundo plano simplificados

¡Perfecto! Funciona como excepción. Puede pasar por varios esquemas CRON aquí que pueden coincidir con sus requisitos. Aquí hay una pequeña documentación agradable para comprender cómo se usan varias expresiones CRON.

Continuaciones

Este es un escenario más complicado. Permítanme tratar de mantenerlo muy simple. Un usuario decide darse de baja de su servicio. Después de que confirme su acción (tal vez haciendo clic en el botón para cancelar la suscripción), nosotros (la aplicación) tenemos que cancelar la suscripción del sistema y enviarle un correo de confirmación después de eso también. Entonces, el primer trabajo es realmente cancelar la suscripción del usuario. El segundo trabajo es enviar un correo confirmando la acción. El segundo trabajo debe ejecutarse solo después de que el primer trabajo se haya completado correctamente. Obtener el escenario?

[HttpPost]
[Route("unsubscribe")]
public IActionResult Unsubscribe(string userName)
{
var jobId = BackgroundJob.Enqueue(() => UnsubscribeUser(userName));
BackgroundJob.ContinueJobWith(jobId, () => Console.WriteLine($"Sent Confirmation Mail to {userName}"));
return Ok($"Unsubscribed");
}

public void UnsubscribeUser(string userName)
{
//Logic to Unsubscribe the user
Console.WriteLine($"Unsubscribed {userName}");
}

Explicación.
Línea #5 El primer trabajo que realmente contiene lógica para eliminar la suscripción del usuario.
Línea #6 Nuestro segundo trabajo que continuará después de que se ejecute el primer trabajo. Esto se hace pasando el Id. de trabajo del trabajo principal a los trabajos secundarios.

Iniciemos la aplicación y vayamos a Postman.

hangfire coont postman Hangfire en ASP.NET Core 3.1 - Trabajos en segundo plano simplificados

hangfire coont dash Hangfire en ASP.NET Core 3.1 - Trabajos en segundo plano simplificados

Ahora, vaya al Tablero y verifique el trabajo exitoso. Verá 2 nuevos trabajos ejecutados en el orden exacto que queríamos. Eso es todo por este tutorial. Espero que tengan claro estos conceptos y les resulte fácil integrar Hangfire en las aplicaciones ASP.NET Core.

Resumen

En esta guía detallada, hemos repasado los conceptos de trabajos en segundo plano, características e implementación de Hangfire en aplicaciones ASP.NET Core y varios tipos de trabajos en Hangfire. El código fuente utilizado para demostrar este tutorial está publicado en GitHub. Te dejo el enlace a continuación para que lo consultes. ¿Tienes experiencia con Hangfire? ¿Tienes alguna consulta/sugerencia? Siéntase libre de dejar a continuación en la sección de comentarios. ¡Feliz codificación!

Fuente: https://codewithmukesh.com/blog/hangfire-in-aspnet-core-3-1/

#aspdotnet #hangfire 

prashant patil

1598286700

whatsapp web-w app web-webs whatsapp »

Through whatsapp web you can easily run whatsapp on your android pc on your android mobile. Just like whatsapp mobile is for android device, whatsapp web is for windows device. Whatsapp web is quite popular which has quite cool features.

whatsapp web

how to use whatsapp web desktop
Whatsapp web is very easy to use. Simply you have to search web.whatsapp.com in your google chrome and click on first result which is the official website of whatsapp web.

As soon as you click, an interface will open in front of you, on which you will see a barcode. Follow the steps given below to use whatsapp web on your desktop

web.whatsapp.com

open your whatsapp on your mobile
You will see 3dots on the right side top inside whatsapp, you have to click
The 3rd option is whatsapp web, you have to click it
Now you have to capture the barcode you see on your desktop through your phone.
Now you can use whatsapp of your android mobile in your desktop
webs whatsapp

note: You can see whatsapp of anyone’s mobile by pointing to the barcode of your desktop. You can also call it whatsapp hack.

Remember that after using whatsapp web, logout it from your desktop. To logout follow the steps given below.

w app web

open your whatsapp on your mobile
You will see 3dots on the right side top inside whatsapp, you have to click
The 3rd option is whatsapp web, you have to click it
You will see the symbol for logout, you have to logout by clicking it.

read more

#whatsapp #whatappweb #https://web.whatsapp.com/ #wsp web #web.whatsapp web #web whatsapp

Jarrod  Douglas

Jarrod Douglas

1660532820

Quelques Bonnes Pratiques Docker Pour Les Développeurs Python

Cet article examine quelques bonnes pratiques à suivre lors de l'écriture de Dockerfiles et de l'utilisation de Docker en général. Alors que la plupart des pratiques répertoriées s'appliquent à tous les développeurs, quel que soit le langage, quelques-unes s'appliquent uniquement à ceux qui développent des applications basées sur Python.

Fichiers Docker

Utiliser des builds en plusieurs étapes

Tirez parti des versions en plusieurs étapes pour créer des images Docker plus légères et plus sécurisées.

Les builds Docker en plusieurs étapes vous permettent de diviser vos Dockerfiles en plusieurs étapes. Par exemple, vous pouvez avoir une étape pour compiler et créer votre application, qui peut ensuite être copiée dans les étapes suivantes. Étant donné que seule la dernière étape est utilisée pour créer l'image, les dépendances et les outils associés à la création de votre application sont ignorés, laissant une image légère et modulaire prête pour la production.

Exemple de développement Web :

# temp stage
FROM python:3.9-slim as builder

WORKDIR /app

ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

RUN apt-get update && \
    apt-get install -y --no-install-recommends gcc

COPY requirements.txt .
RUN pip wheel --no-cache-dir --no-deps --wheel-dir /app/wheels -r requirements.txt


# final stage
FROM python:3.9-slim

WORKDIR /app

COPY --from=builder /app/wheels /wheels
COPY --from=builder /app/requirements.txt .

RUN pip install --no-cache /wheels/*

Dans cet exemple, le compilateur GCC est requis pour l'installation de certains packages Python. Nous avons donc ajouté une étape temporaire de construction pour gérer la phase de construction. Étant donné que l'image d'exécution finale ne contient pas de GCC, elle est beaucoup plus légère et plus sécurisée.

Comparaison de taille :

REPOSITORY                 TAG                    IMAGE ID       CREATED          SIZE
docker-single              latest                 8d6b6a4d7fb6   16 seconds ago   259MB
docker-multi               latest                 813c2fa9b114   3 minutes ago    156MB

Exemple de science des données :

# temp stage
FROM python:3.9 as builder

RUN pip wheel --no-cache-dir --no-deps --wheel-dir /wheels jupyter pandas


# final stage
FROM python:3.9-slim

WORKDIR /notebooks

COPY --from=builder /wheels /wheels
RUN pip install --no-cache /wheels/*

Comparaison de taille :

REPOSITORY                  TAG                   IMAGE ID       CREATED         SIZE
ds-multi                    latest                b4195deac742   2 minutes ago   357MB
ds-single                   latest                7c23c43aeda6   6 minutes ago   969MB

En résumé, les builds en plusieurs étapes peuvent réduire la taille de vos images de production, ce qui vous permet d'économiser du temps et de l'argent. De plus, cela simplifiera vos conteneurs de production. De plus, en raison de la petite taille et de la simplicité, il y a potentiellement une surface d'attaque plus petite.

Commandez les commandes Dockerfile de manière appropriée

Portez une attention particulière à l'ordre de vos commandes Dockerfile pour tirer parti de la mise en cache des couches.

Docker met en cache chaque étape (ou couche) dans un Dockerfile particulier pour accélérer les générations suivantes. Lorsqu'une étape change, le cache est invalidé non seulement pour cette étape particulière, mais pour toutes les étapes suivantes.

Exemple:

FROM python:3.9-slim

WORKDIR /app

COPY sample.py .

COPY requirements.txt .

RUN pip install -r /requirements.txt

Dans ce Dockerfile, nous avons copié le code de l'application avant d'installer les exigences. Maintenant, chaque fois que nous modifions sample.py , la construction réinstallera les packages. Ceci est très inefficace, en particulier lorsque vous utilisez un conteneur Docker comme environnement de développement. Par conséquent, il est crucial de conserver les fichiers qui changent fréquemment vers la fin du Dockerfile.

Vous pouvez également empêcher les invalidations de cache indésirables en utilisant un fichier .dockerignore pour exclure l'ajout de fichiers inutiles au contexte de construction Docker et à l'image finale. Plus d'informations ici sous peu.

Ainsi, dans le Dockerfile ci-dessus, vous devez déplacer la COPY sample.py .commande vers le bas :

FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt .

RUN pip install -r /requirements.txt

COPY sample.py .

Remarques:

  1. Placez toujours les couches susceptibles de changer aussi bas que possible dans le Dockerfile.
  2. Combiner RUN apt-get updateet RUN apt-get installcommandes. (Cela permet également de réduire la taille de l'image. Nous y reviendrons sous peu.)
  3. Si vous souhaitez désactiver la mise en cache pour une version Docker particulière, ajoutez l' --no-cache=Trueindicateur.

Utiliser de petites images de base Docker

Les images Docker plus petites sont plus modulaires et sécurisées.

Construire, pousser et extraire des images est plus rapide avec des images plus petites. Ils ont également tendance à être plus sécurisés car ils n'incluent que les bibliothèques et les dépendances système nécessaires à l'exécution de votre application.

Quelle image de base Docker devez-vous utiliser ?

Malheureusement, cela dépend.

Voici une comparaison de taille de différentes images de base Docker pour Python :

REPOSITORY   TAG                 IMAGE ID       CREATED      SIZE
python       3.9.6-alpine3.14    f773016f760e   3 days ago   45.1MB
python       3.9.6-slim          907fc13ca8e7   3 days ago   115MB
python       3.9.6-slim-buster   907fc13ca8e7   3 days ago   115MB
python       3.9.6               cba42c28d9b8   3 days ago   886MB
python       3.9.6-buster        cba42c28d9b8   3 days ago   886MB

Bien que la version Alpine, basée sur Alpine Linux , soit la plus petite, elle peut souvent entraîner une augmentation des temps de construction si vous ne trouvez pas de binaires compilés qui fonctionnent avec. Par conséquent, vous devrez peut-être construire vous-même les fichiers binaires, ce qui peut augmenter la taille de l'image (en fonction des dépendances requises au niveau du système) et les temps de construction (en raison de la nécessité de compiler à partir de la source).

Reportez-vous à La meilleure image de base Docker pour votre application Python et L'utilisation d'Alpine peut ralentir les constructions de Python Docker 50× pour en savoir plus sur les raisons pour lesquelles il est préférable d'éviter d'utiliser des images de base basées sur Alpine.

Au final, tout est une question d'équilibre. En cas de doute, commencez par une *-slimsaveur, en particulier en mode développement, pendant que vous construisez votre application. Vous souhaitez éviter d'avoir à mettre à jour en permanence le Dockerfile pour installer les dépendances nécessaires au niveau du système lorsque vous ajoutez un nouveau package Python. Au fur et à mesure que vous renforcez votre application et vos Dockerfile(s) pour la production, vous souhaiterez peut-être explorer l'utilisation d'Alpine pour l'image finale à partir d'une construction en plusieurs étapes.

N'oubliez pas non plus de mettre à jour régulièrement vos images de base pour améliorer la sécurité et augmenter les performances. Lorsqu'une nouvelle version d'une image de base est publiée - c'est-à-dire 3.9.6-slim-> 3.9.7-slim- vous devez extraire la nouvelle image et mettre à jour vos conteneurs en cours d'exécution pour obtenir tous les derniers correctifs de sécurité.

Minimiser le nombre de couches

C'est une bonne idée de combiner autant que possible les commandes , et , car elles créent des RUNcalques COPY. ADDChaque calque augmente la taille de l'image car ils sont mis en cache. Par conséquent, à mesure que le nombre de couches augmente, la taille augmente également.

Vous pouvez tester cela avec la docker historycommande :

$ docker images
REPOSITORY   TAG       IMAGE ID       CREATED          SIZE
dockerfile   latest    180f98132d02   51 seconds ago   259MB

$ docker history 180f98132d02

IMAGE          CREATED              CREATED BY                                      SIZE      COMMENT
180f98132d02   58 seconds ago       COPY . . # buildkit                             6.71kB    buildkit.dockerfile.v0
<missing>      58 seconds ago       RUN /bin/sh -c pip install -r requirements.t…   35.5MB    buildkit.dockerfile.v0
<missing>      About a minute ago   COPY requirements.txt . # buildkit              58B       buildkit.dockerfile.v0
<missing>      About a minute ago   WORKDIR /app
...

Attention aux tailles. Seules les commandes RUN, COPYet ADDajoutent de la taille à l'image. Vous pouvez réduire la taille de l'image en combinant des commandes dans la mesure du possible. Par exemple:

RUN apt-get update
RUN apt-get install -y netcat

Peut être combiné en une seule RUNcommande :

RUN apt-get update && apt-get install -y netcat

Ainsi, on crée un seul calque au lieu de deux, ce qui réduit la taille de l'image finale.

Bien que ce soit une bonne idée de réduire le nombre de calques, il est beaucoup plus important que cela soit moins un objectif en soi et plus un effet secondaire de la réduction de la taille de l'image et des temps de construction. En d'autres termes, concentrez-vous davantage sur les trois pratiques précédentes - les constructions en plusieurs étapes, l'ordre de vos commandes Dockerfile et l'utilisation d'une petite image de base - plutôt que d'essayer d'optimiser chaque commande.

Remarques:

  1. RUN, COPY, et ADDcréent chacun des calques.
  2. Chaque couche contient les différences par rapport à la couche précédente.
  3. Les calques augmentent la taille de l'image finale.

Des astuces:

  1. Combinez les commandes associées.
  2. Supprimez les fichiers inutiles dans le même RUN stepqui les a créés.
  3. Réduisez le nombre d' apt-get upgradeexécutions car il met à niveau tous les packages vers la dernière version.
  4. Avec les builds en plusieurs étapes, ne vous inquiétez pas trop de l'optimisation excessive des commandes dans les étapes temporaires.

Enfin, pour plus de lisibilité, c'est une bonne idée de trier les arguments multi-lignes par ordre alphanumérique :

RUN apt-get update && apt-get install -y \
    git \
    gcc \
    matplotlib \
    pillow  \
    && rm -rf /var/lib/apt/lists/*

Utiliser des conteneurs non privilégiés

Par défaut, Docker exécute les processus de conteneur en tant que racine à l'intérieur d'un conteneur. Cependant, il s'agit d'une mauvaise pratique car un processus exécuté en tant que root à l'intérieur du conteneur s'exécute en tant que root dans l'hôte Docker. Ainsi, si un attaquant accède à votre conteneur, il a accès à tous les privilèges root et peut effectuer plusieurs attaques contre l'hôte Docker, comme-

  1. copier des informations sensibles du système de fichiers de l'hôte vers le conteneur
  2. exécuter des commandes à distance

Pour éviter cela, assurez-vous d'exécuter les processus de conteneur avec un utilisateur non root :

RUN addgroup --system app && adduser --system --group app

USER app

Vous pouvez aller plus loin et supprimer l'accès au shell et vous assurer qu'il n'y a pas non plus de répertoire personnel :

RUN addgroup --gid 1001 --system app && \
    adduser --no-create-home --shell /bin/false --disabled-password --uid 1001 --system --group app

USER app

Vérifier:

$ docker run -i sample id

uid=1001(app) gid=1001(app) groups=1001(app)

Ici, l'application dans le conteneur s'exécute sous un utilisateur non root. Cependant, gardez à l'esprit que le démon Docker et le conteneur lui-même fonctionnent toujours avec les privilèges root. Assurez-vous de consulter Exécuter le démon Docker en tant qu'utilisateur non root pour obtenir de l'aide sur l'exécution du démon et des conteneurs en tant qu'utilisateur non root.

Préférez COPIER à AJOUTER

À utiliser COPYsauf si vous êtes certain d'avoir besoin des fonctionnalités supplémentaires fournies avec ADD.

Quelle est la différence entre COPYet ADD?

Les deux commandes vous permettent de copier des fichiers d'un emplacement spécifique dans une image Docker :

ADD <src> <dest>
COPY <src> <dest>

Bien qu'ils semblent servir le même objectif, ils ADDont quelques fonctionnalités supplémentaires :

  • COPYest utilisé pour copier des fichiers ou des répertoires locaux de l'hôte Docker vers l'image.
  • ADDpeut être utilisé pour la même chose ainsi que pour télécharger des fichiers externes. De plus, si vous utilisez un fichier compressé (tar, gzip, bzip2, etc.) comme <src>paramètre, ADDdécompressera automatiquement le contenu à l'emplacement donné.
# copy local files on the host  to the destination
COPY /source/path  /destination/path
ADD /source/path  /destination/path

# download external file and copy to the destination
ADD http://external.file/url  /destination/path

# copy and extract local compresses files
ADD source.file.tar.gz /destination/path

Mettre en cache les packages Python sur l'hôte Docker

Lorsqu'un fichier requirements est modifié, l'image doit être reconstruite pour installer les nouveaux packages. Les étapes précédentes seront mises en cache, comme indiqué dans Réduire le nombre de couches . Le téléchargement de tous les packages lors de la reconstruction de l'image peut entraîner une activité réseau importante et prendre beaucoup de temps. Chaque reconstruction prend le même temps pour télécharger des packages communs à travers les versions.

Vous pouvez éviter cela en mappant le répertoire du cache pip à un répertoire sur la machine hôte. Ainsi, pour chaque reconstruction, les versions mises en cache persistent et peuvent améliorer la vitesse de construction.

Ajoutez un volume au docker exécuté en tant que -v $HOME/.cache/pip-docker/:/root/.cache/pipou en tant que mappage dans le fichier Docker Compose.

Le répertoire présenté ci-dessus est uniquement à titre de référence. Assurez-vous de mapper le répertoire de cache et non les packages de site (où résident les packages construits).

Le déplacement du cache de l'image Docker vers l'hôte peut vous faire gagner de l'espace dans l'image finale.

Si vous utilisez Docker BuildKit , utilisez les montages de cache BuildKit pour gérer le cache :

# syntax = docker/dockerfile:1.2

...

COPY requirements.txt .

RUN --mount=type=cache,target=/root/.cache/pip \
        pip install -r requirements.txt

...

Exécutez un seul processus par conteneur

Pourquoi est-il recommandé de n'exécuter qu'un seul processus par conteneur ?

Supposons que votre pile d'applications se compose de deux serveurs Web et d'une base de données. Bien que vous puissiez facilement exécuter les trois à partir d'un seul conteneur, vous devez exécuter chacun dans un conteneur séparé pour faciliter la réutilisation et la mise à l'échelle de chacun des services individuels.

  1. Mise à l' échelle - Avec chaque service dans un conteneur séparé, vous pouvez mettre à l'échelle l'un de vos serveurs Web horizontalement selon vos besoins pour gérer plus de trafic.
  2. Réutilisabilité - Peut-être avez-vous un autre service qui a besoin d'une base de données conteneurisée. Vous pouvez simplement réutiliser le même conteneur de base de données sans apporter deux services inutiles avec lui.
  3. Journalisation - Le couplage des conteneurs rend la journalisation beaucoup plus complexe. Nous aborderons cela plus en détail plus loin dans cet article.
  4. Portabilité et prévisibilité - Il est beaucoup plus facile de créer des correctifs de sécurité ou de déboguer un problème lorsqu'il y a moins de surface avec laquelle travailler.

Préférer la syntaxe de tableau à la chaîne

Vous pouvez écrire les commandes CMDet ENTRYPOINTdans vos fichiers Docker dans les formats tableau (exec) ou chaîne (shell) :

# array (exec)
CMD ["gunicorn", "-w", "4", "-k", "uvicorn.workers.UvicornWorker", "main:app"]

# string (shell)
CMD "gunicorn -w 4 -k uvicorn.workers.UvicornWorker main:app"

Les deux sont corrects et réalisent presque la même chose ; cependant, vous devez utiliser le format exec chaque fois que possible. De la documentation Docker :

  1. Assurez-vous que vous utilisez le formulaire exec de CMDet ENTRYPOINTdans votre Dockerfile.
  2. Par exemple, n'utilisez ["program", "arg1", "arg2"]pas "program arg1 arg2". L'utilisation de la forme de chaîne oblige Docker à exécuter votre processus à l'aide de bash, qui ne gère pas correctement les signaux. Compose utilise toujours le formulaire JSON, donc ne vous inquiétez pas si vous remplacez la commande ou le point d'entrée dans votre fichier Compose.

Ainsi, puisque la plupart des shells ne traitent pas les signaux vers les processus enfants, si vous utilisez le format shell, CTRL-C(qui génère un SIGTERM) peut ne pas arrêter un processus enfant.

Exemple:

FROM ubuntu:18.04

# BAD: shell format
ENTRYPOINT top -d

# GOOD: exec format
ENTRYPOINT ["top", "-d"]

Essayez les deux. Notez qu'avec la saveur du format shell, CTRL-Ccela ne tuera pas le processus. Au lieu de cela, vous verrez ^C^C^C^C^C^C^C^C^C^C^C.

Une autre mise en garde est que le format shell porte le PID du shell, pas le processus lui-même.

# array format
root@18d8fd3fd4d2:/app# ps ax
  PID TTY      STAT   TIME COMMAND
    1 ?        Ss     0:00 python manage.py runserver 0.0.0.0:8000
    7 ?        Sl     0:02 /usr/local/bin/python manage.py runserver 0.0.0.0:8000
   25 pts/0    Ss     0:00 bash
  356 pts/0    R+     0:00 ps ax


# string format
root@ede24a5ef536:/app# ps ax
  PID TTY      STAT   TIME COMMAND
    1 ?        Ss     0:00 /bin/sh -c python manage.py runserver 0.0.0.0:8000
    8 ?        S      0:00 python manage.py runserver 0.0.0.0:8000
    9 ?        Sl     0:01 /usr/local/bin/python manage.py runserver 0.0.0.0:8000
   13 pts/0    Ss     0:00 bash
  342 pts/0    R+     0:00 ps ax

Comprendre la différence entre ENTRYPOINT et CMD

Dois-je utiliser ENTRYPOINT ou CMD pour exécuter des processus de conteneur ?

Il existe deux manières d'exécuter des commandes dans un conteneur :

CMD ["gunicorn", "config.wsgi", "-b", "0.0.0.0:8000"]

# and

ENTRYPOINT ["gunicorn", "config.wsgi", "-b", "0.0.0.0:8000"]

Les deux font essentiellement la même chose : démarrez l'application sur config.wsgiavec un serveur Gunicorn et liez-la à 0.0.0.0:8000.

Le CMDest facilement contournable. Si vous exécutez docker run <image_name> uvicorn config.asgi, le CMD ci-dessus est remplacé par les nouveaux arguments - par exemple, uvicorn config.asgi. Alors que pour remplacer la ENTRYPOINTcommande, il faut spécifier l' --entrypointoption :

docker run --entrypoint uvicorn config.asgi <image_name>

Ici, il est clair que nous remplaçons le point d'entrée. Il est donc recommandé d'utiliser ENTRYPOINTover CMDpour éviter de remplacer accidentellement la commande.

Ils peuvent également être utilisés ensemble.

Par exemple:

ENTRYPOINT ["gunicorn", "config.wsgi", "-w"]
CMD ["4"]

Lorsqu'ils sont utilisés ensemble comme ceci, la commande qui est exécutée pour démarrer le conteneur est :

gunicorn config.wsgi -w 4

Comme indiqué ci-dessus, CMDest facilement contournable. Ainsi, CMDpeut être utilisé pour passer des arguments à la ENTRYPOINTcommande. Le nombre de travailleurs peut être facilement modifié comme suit :

docker run <image_name> 6

Cela démarrera le conteneur avec six travailleurs Gunicorn plutôt que quatre.

Inclure une instruction HEALTHCHECK

Utilisez a HEALTHCHECKpour déterminer si le processus en cours d'exécution dans le conteneur est non seulement opérationnel, mais également "sain".

Docker expose une API pour vérifier l'état du processus en cours d'exécution dans le conteneur, qui fournit bien plus d'informations que simplement si le processus est "en cours d'exécution" ou non puisque "en cours d'exécution" couvre "il est opérationnel", "en cours de lancement", et même "coincé dans un état d'erreur de boucle infinie". Vous pouvez interagir avec cette API via l' instruction HEALTHCHECK .

Par exemple, si vous diffusez une application Web, vous pouvez utiliser les éléments suivants pour déterminer si le point de /terminaison est opérationnel et peut gérer les requêtes :

HEALTHCHECK CMD curl --fail http://localhost:8000 || exit 1

Si vous exécutez docker ps, vous pouvez voir l'état du HEALTHCHECK.

Exemple sain :

CONTAINER ID   IMAGE         COMMAND                  CREATED          STATUS                            PORTS                                       NAMES
09c2eb4970d4   healthcheck   "python manage.py ru…"   10 seconds ago   Up 8 seconds (health: starting)   0.0.0.0:8000->8000/tcp, :::8000->8000/tcp   xenodochial_clarke

Exemple malsain :

CONTAINER ID   IMAGE         COMMAND                  CREATED              STATUS                          PORTS                                       NAMES
09c2eb4970d4   healthcheck   "python manage.py ru…"   About a minute ago   Up About a minute (unhealthy)   0.0.0.0:8000->8000/tcp, :::8000->8000/tcp   xenodochial_clarke

Vous pouvez aller plus loin et configurer un point de terminaison personnalisé utilisé uniquement pour les vérifications de l'état, puis configurer le HEALTHCHECKpour tester les données renvoyées. Par exemple, si le point de terminaison renvoie une réponse JSON de {"ping": "pong"}, vous pouvez demander au HEALTHCHECKde valider le corps de la réponse.

Voici comment afficher l'état de la vérification de l'état à l'aide dedocker inspect :

❯ docker inspect --format "{{json .State.Health }}" ab94f2ac7889
{
  "Status": "healthy",
  "FailingStreak": 0,
  "Log": [
    {
      "Start": "2021-09-28T15:22:57.5764644Z",
      "End": "2021-09-28T15:22:57.7825527Z",
      "ExitCode": 0,
      "Output": "..."

Ici, la sortie est coupée car elle contient toute la sortie HTML.

Vous pouvez également ajouter une vérification d'état à un fichier Docker Compose :

version: "3.8"

services:
  web:
    build: .
    ports:
      - '8000:8000'
    healthcheck:
      test: curl --fail http://localhost:8000 || exit 1
      interval: 10s
      timeout: 10s
      start_period: 10s
      retries: 3

Option :

  • test: La commande à tester.
  • interval: L'intervalle à tester -- c'est-à-dire, testez chaque xunité de temps.
  • timeout: Temps maximum d'attente de la réponse.
  • start_period: Quand commencer le bilan de santé. Il peut être utilisé lorsque des tâches supplémentaires sont effectuées avant que les conteneurs ne soient prêts, comme l'exécution de migrations.
  • retries: nombre maximal de tentatives avant de désigner un test comme failed.

Si vous utilisez un outil d'orchestration autre que Docker Swarm, c'est-à-dire Kubernetes ou AWS ECS, il est fort probable que l'outil dispose de son propre système interne pour gérer les vérifications de l'état. Reportez-vous à la documentation de l'outil particulier avant d'ajouter l' HEALTHCHECKinstruction.

Images

Version des images Docker

Dans la mesure du possible, évitez d'utiliser la latestbalise.

Si vous vous fiez à la latestbalise (qui n'est pas vraiment une "balise" puisqu'elle est appliquée par défaut lorsqu'une image n'est pas explicitement balisée), vous ne pouvez pas savoir quelle version de votre code s'exécute en fonction de la balise d'image. Cela complique les restaurations et facilite leur écrasement (accidentellement ou par malveillance). Les balises, comme votre infrastructure et vos déploiements, doivent être immuables .

Quelle que soit la façon dont vous traitez vos images internes, vous ne devez jamais utiliser la latestbalise pour les images de base, car vous pourriez déployer par inadvertance une nouvelle version avec des modifications radicales en production.

Pour les images internes, utilisez des balises descriptives pour identifier plus facilement la version du code en cours d'exécution, gérer les restaurations et éviter les collisions de noms.

Par exemple, vous pouvez utiliser les descripteurs suivants pour créer une balise :

  1. Horodatages
  2. ID d'image Docker
  3. Git commit hachages
  4. Version sémantique

Pour plus d'options, consultez cette réponse de la question Stack Overflow "Version correcte des images Docker".

Par exemple:

docker build -t web-prod-a072c4e5d94b5a769225f621f08af3d4bf820a07-0.1.4 .

Ici, nous avons utilisé ce qui suit pour former la balise :

  1. Nom du projet:web
  2. Nom de l'environnement :prod
  3. Hachage de validation Git :a072c4e5d94b5a769225f621f08af3d4bf820a07
  4. Version sémantique :0.1.4

Il est essentiel de choisir un schéma de marquage et d'être cohérent avec celui-ci. Étant donné que les hachages de commit permettent de lier rapidement une balise d'image au code, il est fortement recommandé de les inclure dans votre schéma de balisage.

Ne stockez pas de secrets dans les images

Les secrets sont des informations sensibles telles que les mots de passe, les informations d'identification de la base de données, les clés SSH, les jetons et les certificats TLS, pour n'en nommer que quelques-uns. Ceux-ci ne doivent pas être intégrés à vos images sans être cryptés, car les utilisateurs non autorisés qui accèdent à l'image peuvent simplement examiner les couches pour en extraire les secrets.

N'ajoutez pas de secrets à vos Dockerfiles en clair, surtout si vous poussez les images vers un registre public comme Docker Hub :

FROM python:3.9-slim

ENV DATABASE_PASSWORD "SuperSecretSauce"

Au lieu de cela, ils doivent être injectés via :

  1. Variables d'environnement (au moment de l'exécution)
  2. Arguments au moment de la construction (au moment de la construction)
  3. Un outil d'orchestration comme Docker Swarm (via les secrets Docker) ou Kubernetes (via les secrets Kubernetes)

En outre, vous pouvez aider à empêcher les fuites de secrets en ajoutant des fichiers et des dossiers secrets communs à votre fichier .dockerignore :

**/.env
**/.aws
**/.ssh

Enfin, soyez explicite sur les fichiers qui sont copiés sur l'image plutôt que de copier tous les fichiers de manière récursive :

# BAD
COPY . .

# GOOD
copy ./app.py .

Être explicite aide également à limiter le contournement du cache.

Variables d'environnement

Vous pouvez transmettre des secrets via des variables d'environnement, mais ils seront visibles dans tous les processus enfants, conteneurs liés et journaux, ainsi que via docker inspect. Il est également difficile de les mettre à jour.

$ docker run --detach --env "DATABASE_PASSWORD=SuperSecretSauce" python:3.9-slim

d92cf5cf870eb0fdbf03c666e7fcf18f9664314b79ad58bc7618ea3445e39239


$ docker inspect --format='{{range .Config.Env}}{{println .}}{{end}}' d92cf5cf870eb0fdbf03c666e7fcf18f9664314b79ad58bc7618ea3445e39239

DATABASE_PASSWORD=SuperSecretSauce
PATH=/usr/local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
LANG=C.UTF-8
GPG_KEY=E3FF2839C048B25C084DEBE9B26995E310250568
PYTHON_VERSION=3.9.7
PYTHON_PIP_VERSION=21.2.4
PYTHON_SETUPTOOLS_VERSION=57.5.0
PYTHON_GET_PIP_URL=https://github.com/pypa/get-pip/raw/c20b0cfd643cd4a19246ccf204e2997af70f6b21/public/get-pip.py
PYTHON_GET_PIP_SHA256=fa6f3fb93cce234cd4e8dd2beb54a51ab9c247653b52855a48dd44e6b21ff28b

Il s'agit de l'approche la plus simple de la gestion des secrets. Bien que ce ne soit pas le plus sûr, il gardera les gens honnêtes honnêtes car il fournit une fine couche de protection, aidant à garder les secrets cachés des yeux curieux et errants.

Transmettre des secrets en utilisant un volume partagé est une meilleure solution, mais ils doivent être chiffrés, via Vault ou AWS Key Management Service (KMS), car ils sont enregistrés sur disque.

Arguments de construction

Vous pouvez transmettre des secrets au moment de la construction en utilisant des arguments de construction , mais ils seront visibles pour ceux qui ont accès à l'image via docker history.

Exemple:

FROM python:3.9-slim

ARG DATABASE_PASSWORD

Construire:

$ docker build --build-arg "DATABASE_PASSWORD=SuperSecretSauce" .

Si vous n'avez besoin d'utiliser les secrets que temporairement dans le cadre de la construction, c'est-à-dire des clés SSH pour cloner un référentiel privé ou télécharger un package privé, vous devez utiliser une construction en plusieurs étapes, car l'historique du générateur est ignoré pour les étapes temporaires :

# temp stage
FROM python:3.9-slim as builder

# secret
ARG SSH_PRIVATE_KEY

# install git
RUN apt-get update && \
    apt-get install -y --no-install-recommends git

# use ssh key to clone repo
RUN mkdir -p /root/.ssh/ && \
    echo "${PRIVATE_SSH_KEY}" > /root/.ssh/id_rsa
RUN touch /root/.ssh/known_hosts &&
    ssh-keyscan bitbucket.org >> /root/.ssh/known_hosts
RUN git clone git@github.com:testdrivenio/not-real.git


# final stage
FROM python:3.9-slim

WORKDIR /app

# copy the repository from the temp image
COPY --from=builder /your-repo /app/your-repo

# use the repo for something!

La construction en plusieurs étapes ne conserve l'historique que pour l'image finale. Gardez à l'esprit que vous pouvez utiliser cette fonctionnalité pour les secrets permanents dont vous avez besoin pour votre application, comme un identifiant de base de données.

Vous pouvez également utiliser la nouvelle --secretoption dans Docker build pour transmettre des secrets aux images Docker qui ne sont pas stockées dans les images.

# "docker_is_awesome" > secrets.txt

FROM alpine

# shows secret from default secret location:
RUN --mount=type=secret,id=mysecret cat /run/secrets/mysecret

Cela montera le secret à partir du secrets.txtfichier.

Construisez l'image :

docker build --no-cache --progress=plain --secret id=mysecret,src=secrets.txt .

# output
...
#4 [1/2] FROM docker.io/library/alpine
#4 sha256:665ba8b2cdc0cb0200e2a42a6b3c0f8f684089f4cd1b81494fbb9805879120f7
#4 CACHED

#5 [2/2] RUN --mount=type=secret,id=mysecret cat /run/secrets/mysecret
#5 sha256:75601a522ebe80ada66dedd9dd86772ca932d30d7e1b11bba94c04aa55c237de
#5 0.635 docker_is_awesome#5 DONE 0.7s

#6 exporting to image

Enfin, vérifiez l'historique pour voir si le secret fuit :

❯ docker history 49574a19241c
IMAGE          CREATED         CREATED BY                                      SIZE      COMMENT
49574a19241c   5 minutes ago   CMD ["/bin/sh"]                                 0B        buildkit.dockerfile.v0
<missing>      5 minutes ago   RUN /bin/sh -c cat /run/secrets/mysecret # b…   0B        buildkit.dockerfile.v0
<missing>      4 weeks ago     /bin/sh -c #(nop)  CMD ["/bin/sh"]              0B
<missing>      4 weeks ago     /bin/sh -c #(nop) ADD file:aad4290d27580cc1a…   5.6MB

Pour en savoir plus sur les secrets de construction, consultez Ne divulguez pas les secrets de construction de votre image Docker .

Les secrets de Docker

Si vous utilisez Docker Swarm , vous pouvez gérer les secrets avec Docker secrets .

Par exemple, initialisez le mode Docker Swarm :

$ docker swarm init

Créez un secret Docker :

$ echo "supersecretpassword" | docker secret create postgres_password -
qdqmbpizeef0lfhyttxqfbty0

$ docker secret ls
ID                          NAME                DRIVER    CREATED         UPDATED
qdqmbpizeef0lfhyttxqfbty0   postgres_password             4 seconds ago   4 seconds ago

Lorsqu'un conteneur a accès au secret ci-dessus, il se monte sur /run/secrets/postgres_password. Ce fichier contiendra la valeur réelle du secret en clair.

Vous utilisez un autre outil d'orhestration ?

  1. AWS EKS - Utilisation des secrets AWS Secrets Manager avec Kubernetes
  2. DigitalOcean Kubernetes - Étapes recommandées pour sécuriser un cluster DigitalOcean Kubernetes
  3. Google Kubernetes Engine – Utilisation de Secret Manager avec d'autres produits
  4. Nomad - Intégration Vault et récupération des secrets dynamiques

Utiliser un fichier .dockerignore

Nous avons déjà mentionné plusieurs fois l'utilisation d'un fichier .dockerignore . Ce fichier est utilisé pour spécifier les fichiers et dossiers que vous ne souhaitez pas ajouter au contexte de construction initial envoyé au démon Docker, qui construira ensuite votre image. En d'autres termes, vous pouvez l'utiliser pour définir le contexte de génération dont vous avez besoin.

Lorsqu'une image Docker est construite, l'intégralité du contexte Docker, c'est-à-dire la racine de votre projet, est envoyée au démon Docker avant que les commandes COPYou ADDne soient évaluées. Cela peut être assez coûteux, surtout si vous avez de nombreuses dépendances, des fichiers de données volumineux ou des artefacts de construction dans votre projet. De plus, la CLI Docker et le démon peuvent ne pas être sur la même machine. Ainsi, si le démon est exécuté sur une machine distante, vous devez être encore plus attentif à la taille du contexte de construction.

Que devez-vous ajouter au fichier .dockerignore ?

  1. Fichiers et dossiers temporaires
  2. Construire des journaux
  3. Secrets locaux
  4. Fichiers de développement locaux comme docker-compose.yml
  5. Dossiers de contrôle de version tels que ".git", ".hg" et ".svn"

Exemple:

**/.git
**/.gitignore
**/.vscode
**/coverage
**/.env
**/.aws
**/.ssh
Dockerfile
README.md
docker-compose.yml
**/.DS_Store
**/venv
**/env

En résumé, un .dockerignore correctement structuré peut aider :

  1. Diminuer la taille de l'image Docker
  2. Accélérez le processus de construction
  3. Empêcher l'invalidation inutile du cache
  4. Empêcher les fuites de secrets

Lint et scanne vos Dockerfiles et images

Le peluchage est le processus de vérification de votre code source pour les erreurs programmatiques et stylistiques et les mauvaises pratiques qui pourraient conduire à des défauts potentiels. Tout comme avec les langages de programmation, les fichiers statiques peuvent également être pelucheux. Avec vos Dockerfiles en particulier, les linters peuvent vous aider à vous assurer qu'ils sont maintenables, à éviter une syntaxe obsolète et à respecter les meilleures pratiques. Le peluchage de vos images devrait faire partie intégrante de vos pipelines CI.

Hadolint est le linter Dockerfile le plus populaire :

$ hadolint Dockerfile

Dockerfile:1 DL3006 warning: Always tag the version of an image explicitly
Dockerfile:7 DL3042 warning: Avoid the use of cache directory with pip. Use `pip install --no-cache-dir <package>`
Dockerfile:9 DL3059 info: Multiple consecutive `RUN` instructions. Consider consolidation.
Dockerfile:17 DL3025 warning: Use arguments JSON notation for CMD and ENTRYPOINT arguments

Vous pouvez le voir en action en ligne sur https://hadolint.github.io/hadolint/ . Il existe également une extension de code VS.

Vous pouvez coupler vos Dockerfiles avec l'analyse d'images et de conteneurs pour les vulnérabilités.

Quelques options :

  1. Snyk est le fournisseur exclusif d'analyse de vulnérabilité native pour Docker. Vous pouvez utiliser la docker scancommande CLI pour numériser des images.
  2. Trivy peut être utilisé pour analyser des images de conteneurs, des systèmes de fichiers, des référentiels git et d'autres fichiers de configuration.
  3. Clair est un projet open source utilisé pour l'analyse statique des vulnérabilités dans les conteneurs d'applications.
  4. Anchore est un projet open source qui fournit un service centralisé pour l'inspection, l'analyse et la certification des images de conteneurs.

En résumé, peluchez et analysez vos Dockerfiles et images pour faire apparaître tout problème potentiel qui s'écarte des meilleures pratiques.

Signer et vérifier les images

Comment savez-vous que les images utilisées pour exécuter votre code de production n'ont pas été altérées ?

La falsification peut passer par le fil via des attaques de l' homme du milieu (MITM) ou du fait que le registre est complètement compromis.

Docker Content Trust (DCT) permet la signature et la vérification des images Docker à partir de registres distants.

Pour vérifier l'intégrité et l'authenticité d'une image, définissez la variable d'environnement suivante :

DOCKER_CONTENT_TRUST=1

Maintenant, si vous essayez d'extraire une image qui n'a pas été signée, vous recevrez l'erreur suivante :

Error: remote trust data does not exist for docker.io/namespace/unsigned-image:
notary.docker.io does not have trust data for docker.io/namespace/unsigned-image

Vous pouvez en savoir plus sur la signature d'images dans la documentation Signature d'images avec Docker Content Trust .

Lorsque vous téléchargez des images depuis Docker Hub, assurez-vous d'utiliser des images officielles ou des images vérifiées provenant de sources fiables. Les équipes plus importantes devraient envisager d'utiliser leur propre registre de conteneurs privé interne .

Conseils bonus

Utilisation des environnements virtuels Python

Devriez-vous utiliser un environnement virtuel à l'intérieur d'un conteneur ?

Dans la plupart des cas, les environnements virtuels sont inutiles tant que vous vous en tenez à n'exécuter qu'un seul processus par conteneur. Étant donné que le conteneur lui-même fournit une isolation, les packages peuvent être installés à l'échelle du système. Cela dit, vous souhaiterez peut-être utiliser un environnement virtuel dans une construction en plusieurs étapes plutôt que de créer des fichiers de roue.

Exemple avec roues :

# temp stage
FROM python:3.9-slim as builder

WORKDIR /app

ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

RUN apt-get update && \
    apt-get install -y --no-install-recommends gcc

COPY requirements.txt .
RUN pip wheel --no-cache-dir --no-deps --wheel-dir /app/wheels -r requirements.txt


# final stage
FROM python:3.9-slim

WORKDIR /app

COPY --from=builder /app/wheels /wheels
COPY --from=builder /app/requirements.txt .

RUN pip install --no-cache /wheels/*

Exemple avec virtualenv :

# temp stage
FROM python:3.9-slim as builder

WORKDIR /app

ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

RUN apt-get update && \
    apt-get install -y --no-install-recommends gcc

RUN python -m venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"

COPY requirements.txt .
RUN pip install -r requirements.txt


# final stage
FROM python:3.9-slim

COPY --from=builder /opt/venv /opt/venv

WORKDIR /app

ENV PATH="/opt/venv/bin:$PATH"

Définir les limites de la mémoire et du processeur

It's a good idea to limit the memory usage of your Docker containers, especially if you're running multiple containers on a single machine. This can prevent any of the containers from using all available memory and thereby crippling the rest.

The easiest way to limit memory usage is to use --memory and --cpu options in the Docker cli:

$ docker run --cpus=2 -m 512m nginx

The above command limits the container usage to 2 CPUs and 512 megabytes of main memory.

You can do the same in a Docker Compose file like so:

version: "3.9"
services:
  redis:
    image: redis:alpine
    deploy:
      resources:
        limits:
          cpus: 2
          memory: 512M
        reservations:
          cpus: 1
          memory: 256M

Take note of the reservations field. It's used to set a soft limit, which takes priority when the host machine has low memory or CPU resources.

Additional resources:

  1. Runtime options with Memory, CPUs, and GPUs
  2. Docker Compose resouce constraints

Log to stdout or stderr

Les applications exécutées dans vos conteneurs Docker doivent écrire des messages de journal sur la sortie standard (stdout) et l'erreur standard (stderr) plutôt que sur un fichier.

Vous pouvez ensuite configurer le démon Docker pour envoyer vos messages de journal à une solution de journalisation centralisée (comme CloudWatch Logs ou Papertrail ).

Pour en savoir plus, consultez Traiter les journaux comme des flux d'événements à partir de l'application Twelve-Factor et Configurer les pilotes de journalisation à partir de la documentation Docker.

Utiliser une monture de mémoire partagée pour Gunicorn Heartbeat

Gunicorn utilise un système de pulsation basé sur des fichiers pour s'assurer que tous les processus de travail forkés sont actifs.

Dans la plupart des cas, les fichiers heartbeat se trouvent dans "/tmp", qui est souvent en mémoire via tmpfs . Étant donné que Docker n'utilise pas tmpfs par défaut, les fichiers seront stockés sur un système de fichiers sauvegardé sur disque. Cela peut causer des problèmes , comme des gels aléatoires puisque le système de pulsation utilise os.fchmod, ce qui peut bloquer un travailleur si le répertoire se trouve en fait sur un système de fichiers sauvegardé sur disque.

Heureusement, il existe une solution simple : remplacez le répertoire heartbeat par un répertoire mappé en mémoire via le --worker-tmp-dirdrapeau.

gunicorn --worker-tmp-dir /dev/shm config.wsgi -b 0.0.0.0:8000

Conclusion

Cet article a examiné plusieurs bonnes pratiques pour rendre vos Dockerfiles et images plus propres, plus légers et plus sécurisés.

Source :  https://testdrive.io

#python #docker