Albany, NY, USA; Saint Mary's Gaels guard Augustas Marciulionis (3) dribbles the ball against Connecticut Huskies guard Andre Jackson Jr. (44) during the second half at MVP Arena. Mandatory Credit: Gregory Fisher-USA TODAY Sports When last seen at the NCAA Tournament,

No. 23 Saint Mary's aims to shut down Div. II Stanislaus State

Deion Sanders' debut as Colorado coach was billed as a big deal of a closely watched offseason. There was plenty of skepticism about just how good the Buffaloes could be after an unprecedented roster makeover in Boulder.

Nighttime becomes the right time for November football in the Big Ten

Love United Iredell is a project-based fundraising program that unites the community around local causes and nonprofit organizations during the month of February. This initiative is a way for an Iredell County based nonprofit to educate the community-at ...

United Way accepting applications for Love United Iredell campaign

A committee of dedicated volunteers including a certain Vernon Robinson is working hard to keep the Triad Veterans Parade rolling in downtown.

Two Things: We love a (Veterans) parade; a necessary inconvenience for motorists

Across the country, family members of children, parents and other relatives struggling with the disease of addiction are facing new financial burdens whether it’s missing work, blowing through their s

Addiction can lead to financial ruin. Ohio wants to teach finance pros to help stem the loss

"We are honored to recognize them on this special day in Opelika. It’s because of our veterans that future generations can enjoy a life of freedom,” Mayor Gary Fuller said.

Opelika to honor local vets with free breakfast in celebration of Veteran's Day

As interest rates and material costs have gone up in recent years, the cost of developing new housing has risen with them. But, there is some hope, community leaders say.

A place to roost: The impact of the national housing shortage in Columbus

Tickets are almost gone and you don’t want to miss out on our annual fundraiser Dancing for the Arts! Saturday, Nov 4. Tickets include a Gala Reception with food by @doughgirls_catering and your favorite selections of beer and wine on us! Watch as local ...

Dancing for the Arts! this Saturday in Concord

WATERLOO — Chawne Paige thinks it’s time for holiday shoppers to get creative. Of course, they may be tempted to play the “one for you, two for me game” while checking off names on their gift lists during the Holiday Arts Festival.

Wrap up gift shopping Nov. 11 at Waterloo Center for the Arts' Holiday Arts Festival

A new sandwich shop is set to open in Downtown Boise. Don & Charly’s is slated to open at 103 N. 10th St., next to Zen Bento. The restaurant space has seen significant turnover in recent years – this summer it was the Frondescence vegetarian restaurant,

Sandwich & charcuterie shop set for Downtown Boise

Getlocal

getlocal

Source Code Analysis of Apache SeaTunnel Zeta Engine (Part 1): Server Initialization

Efficient API Interaction And Consumption With Laravel: A Beginner's Guide

Corporate extraction is eating everything. The tech monopoly is destroying us. The unicorn startup model is broken. We need economies that support collective flourishing. What is an Economy of Specificity?: The Coffee Shop and Starbucks Starbucks’ strategy has been ubiquitous reproducibility. Globally, you can walk into a starbucks, and get pretty much the same product, no matter where you are. Starbucks does actually adapt some to local cultures, adding menu items exclusive to a particular place and palette. But the business model is copy and paste. And Starbucks is everywhere, at one point seeking to be visible from every office window in cities like NYC or their home of Seattle. It does not matter who is working behind the counter, nor what local bean roasters might be in business, Starbucks will produce the same cup of coffee and carry the same pre-roasted beans on the shelf. This is in contrast to the local coffee shop that roasts their own beans which they source from a few family farms in Guatemala. The person working behind the counter matters quite a bit, not just for their skill as a barista, but as a source of community news and gossip. This coffee shop might work with a local bakery, or add a menu item named after one of their regular customers. While still tied into global networks of exchange, this is an economy of specificity. They are reliant on their particular relationships and exist only in their context. But local coffee shops are a pattern, a global phenomenon. Collectively they have a greater market share than coffee chains, even though they are not organized under a single business. Their risks and rewards are distributed. Economies of specificity make communities richer. Rather than extracting wealth for global corporations, the more local, “inefficient”, flows of exchange feed back into the mutual relationships that these economies require. They also make communities richer in the sense that they increase intangible values like quality and uniqueness while knitting the social relationships that are needed for sustainability. Here is a list of a few examples, dividing between Copy-Paste Economies and Economies of Specificity. Mushrooms and Culture When Anna Tsing talks about the networks of matsutake mushroom hunters in The Mushroom at the End of the World, she is talking about an economy of specificity. These networks span the globe, but each step in their processes of discovery, exchange, pricing, and meaning making is relational and specific — not just in place, but also time. Matsutake resists industrial mushroom growing practices and in each place it grows it does so in a different way, favoring different environmental conditions. The people who hunt the mushroom do so for a variety of reasons, but each group is somehow bound to the agency that mushroom hunting gives them. And the networks of sale and exchange that set the price of the mushroom are deeply embedded in the relationships between cultures. When I think about the Indigenous “three sisters” agricultural method of planting corn, beans, and squash together so that they balance the soil nutrients and increase yields, I see that as an economy of specificity. This method doesn’t work for industrial farming because industrial agriculture scales through automation, minimizing labor. But the three sisters have to be harvested by hand. Quality and labor intensity are an intertwined pair. While it may be “inefficient” to have to employ more labor, from a societal perspective we can see the benefits of high-quality, low-waste industries that create jobs. Really, it’s just a different type of efficiency, tuned for different goals. When I think about the slow food movement I am reminded that economies of specificity support each other. One local farm has limited effect, but a network of farm-to-table restaurants, farms, bee keepers, composting services, and local artisans all working in collaboration has the power to change economic conditions for an entire region. And this can go further; groups from workers cooperatives to land stewards can be connected through something as innocuous as a matsutake mushroom. The individual businesses and actors are unique and highly specific. They are both irreplaceable and unimportant on their own. But because they are in networks of mutual support, they are powerful. Copy-Paste Economies spread through capital, hostile takeovers, and market dominance. Economies of Specificity spread through culture. They are patterns without prescription. What Does Any of This Have to Do with Tech? Well, I’ve been thinking about the Cozy Web lately. Secluded spaces like Discord servers, niche forums, and Signal group chats are where a lot of the activity of the web actually happens. These spaces allow for customization and cultural development, in contrast to the large social platforms like Meta and X. The large social platforms rely on advertising and the collection of user data. They operate through scaled, ubiquitous extraction. What is the economics of the cozy web? A lot of institutions like Signal have to rely on donations and public funding. This is one model, but we need more. And I see economies of specificity as one lens through which to find solutions. SAAS is one model that can be revolutionized from its current form. What if we were paying development teams to add custom features to open-source software? This would open up a direct line between user needs and software development. It also provides a more direct funding stream for the maintainers who keep the fundamental building blocks of our networks functional (and yes I am thinking of the XZ Utils incident and the classic xkcd comic Dependency). Additionally, as we start seeing more peer-to-peer software that can provide interconnectivity without servers, the SAAS model will need to adapt. Similarly, we need more custom web designers and less Wix sites. We need more applications built for local township governance, food waste mitigation, and citizen science. B2B applications are an opportunity for custom solutions to situated problems. Approaching development as an act of customizing open-source software lowers overhead while building more fit to purpose applications and creating a thriving developer industry. Not everything needs to be a unicorn startup that gets sold off to the same monopolies capturing the rest of the internet. We need to rewild the internet, and also our economies.** Competing with Copy-Paste Economies And I believe that technology has the power to help economies of specificity compete with copy-paste economies. When I talk about networks of mutual support, I recognize that these networks are always bounded by the friction of communication, the time it takes to transport goods, and the amount of information in the system about the needs of each of the different businesses. Amazon can have a super precise and flexible distribution network that lets you receive packages the next day, because they control all of the information about their business centrally. As I write I am watching the UPS guy unload six packages with Amazon logos that he is delivering along my block. Each of these packages has a tracking number that will be scanned as they are delivered; photos of them will be uploaded and attached to that number; and emails will be sent to customers. Amazon’s warehousing information systems let them know exactly what is on the shelf at any moment, coordinating the fastest and most efficient delivery of the thousands and thousands of products. Why were these packages delivered by UPS when yesterday it was an amazon branded van driving down the block? Rather than the central information system that lets Amazon function, imagine information tools that help the actors in economies of specificity to coordinate on both local and global scales. If a farm is suddenly unable to supply romaine lettuce to the restaurant that they are contracted with, what other farms can fulfill the order at the last minute? How does the emission of carbon in a specific development project affect the global climate? There are a number of technologies that enable this flexibility and data availability without devolving into extractive systems that require uniformity and cannot handle the uniqueness of these local networks and specific economic relationships. Mutual credit currencies and REA accounting allow for demand side value flows. Peer-to-peer software allows for shared ownership of data, supplanting centralization and silos. And local-first software means these peer networks can operate with a really small minimum viable number of actors or scale up to global levels as needed. Together, along with economies of specificity and other economic and social shifts like cooperatives, it is possible to have the benefits of Amazon and Starbucks without destroying our planet. All while enriching our local communities. Special thanks to my colleagues Camila Hanada, Jarod Holtz, and Paul d’Aoust for their enriching reviews and assistance with this article’s feature image. All mistakes and opinions remain my own. Corporate extraction is eating everything. The tech monopoly is destroying us. The unicorn startup model is broken. We need economies that support collective flourishing. What is an Economy of Specificity?: The Coffee Shop and Starbucks What is an Economy of Specificity?: The Coffee Shop and Starbucks Starbucks’ strategy has been ubiquitous reproducibility. Globally, you can walk into a starbucks, and get pretty much the same product, no matter where you are. Starbucks does actually adapt some to local cultures, adding menu items exclusive to a particular place and palette. But the business model is copy and paste. And Starbucks is everywhere, at one point seeking to be visible from every office window in cities like NYC or their home of Seattle. It does not matter who is working behind the counter, nor what local bean roasters might be in business, Starbucks will produce the same cup of coffee and carry the same pre-roasted beans on the shelf. This is in contrast to the local coffee shop that roasts their own beans which they source from a few family farms in Guatemala. The person working behind the counter matters quite a bit, not just for their skill as a barista, but as a source of community news and gossip. This coffee shop might work with a local bakery, or add a menu item named after one of their regular customers. While still tied into global networks of exchange, this is an economy of specificity. They are reliant on their particular relationships and exist only in their context. But local coffee shops are a pattern, a global phenomenon. Collectively they have a greater market share than coffee chains, even though they are not organized under a single business. Their risks and rewards are distributed. greater market share greater market share Economies of specificity make communities richer. Rather than extracting wealth for global corporations, the more local, “inefficient”, flows of exchange feed back into the mutual relationships that these economies require. They also make communities richer in the sense that they increase intangible values like quality and uniqueness while knitting the social relationships that are needed for sustainability. Here is a list of a few examples, dividing between Copy-Paste Economies and Economies of Specificity. Mushrooms and Culture When Anna Tsing talks about the networks of matsutake mushroom hunters in The Mushroom at the End of the World , she is talking about an economy of specificity. These networks span the globe, but each step in their processes of discovery, exchange, pricing, and meaning making is relational and specific — not just in place, but also time. Matsutake resists industrial mushroom growing practices and in each place it grows it does so in a different way, favoring different environmental conditions. The people who hunt the mushroom do so for a variety of reasons, but each group is somehow bound to the agency that mushroom hunting gives them. And the networks of sale and exchange that set the price of the mushroom are deeply embedded in the relationships between cultures. The Mushroom at the End of the World The Mushroom at the End of the World The Mushroom at the End of the World When I think about the Indigenous “three sisters” agricultural method of planting corn, beans, and squash together so that they balance the soil nutrients and increase yields, I see that as an economy of specificity. This method doesn’t work for industrial farming because industrial agriculture scales through automation, minimizing labor. But the three sisters have to be harvested by hand. Quality and labor intensity are an intertwined pair. While it may be “inefficient” to have to employ more labor, from a societal perspective we can see the benefits of high-quality, low-waste industries that create jobs. Really, it’s just a different type of efficiency, tuned for different goals. When I think about the slow food movement I am reminded that economies of specificity support each other. One local farm has limited effect, but a network of farm-to-table restaurants, farms, bee keepers, composting services, and local artisans all working in collaboration has the power to change economic conditions for an entire region. And this can go further; groups from workers cooperatives to land stewards can be connected through something as innocuous as a matsutake mushroom. slow food movement slow food movement The individual businesses and actors are unique and highly specific. They are both irreplaceable and unimportant on their own. But because they are in networks of mutual support, they are powerful. Copy-Paste Economies spread through capital, hostile takeovers, and market dominance. Economies of Specificity spread through culture. They are patterns without prescription. What Does Any of This Have to Do with Tech? Well, I’ve been thinking about the Cozy Web lately. Secluded spaces like Discord servers, niche forums, and Signal group chats are where a lot of the activity of the web actually happens. These spaces allow for customization and cultural development, in contrast to the large social platforms like Meta and X. The large social platforms rely on advertising and the collection of user data. They operate through scaled, ubiquitous extraction. Cozy Web Cozy Web What is the economics of the cozy web? A lot of institutions like Signal have to rely on donations and public funding. This is one model, but we need more. And I see economies of specificity as one lens through which to find solutions. SAAS is one model that can be revolutionized from its current form. What if we were paying development teams to add custom features to open-source software? This would open up a direct line between user needs and software development. It also provides a more direct funding stream for the maintainers who keep the fundamental building blocks of our networks functional (and yes I am thinking of the XZ Utils incident and the classic xkcd comic Dependency ). XZ Utils incident XZ Utils incident Dependency Dependency Dependency Additionally, as we start seeing more peer-to-peer software that can provide interconnectivity without servers, the SAAS model will need to adapt. Similarly, we need more custom web designers and less Wix sites. We need more applications built for local township governance, food waste mitigation, and citizen science. B2B applications are an opportunity for custom solutions to situated problems. Approaching development as an act of customizing open-source software lowers overhead while building more fit to purpose applications and creating a thriving developer industry. Not everything needs to be a unicorn startup that gets sold off to the same monopolies capturing the rest of the internet. We need to rewild the internet , and also our economies.** We need to rewild the internet We need to rewild the internet Competing with Copy-Paste Economies And I believe that technology has the power to help economies of specificity compete with copy-paste economies. When I talk about networks of mutual support, I recognize that these networks are always bounded by the friction of communication, the time it takes to transport goods, and the amount of information in the system about the needs of each of the different businesses. Amazon can have a super precise and flexible distribution network that lets you receive packages the next day, because they control all of the information about their business centrally. As I write I am watching the UPS guy unload six packages with Amazon logos that he is delivering along my block. Each of these packages has a tracking number that will be scanned as they are delivered; photos of them will be uploaded and attached to that number; and emails will be sent to customers. Amazon’s warehousing information systems let them know exactly what is on the shelf at any moment, coordinating the fastest and most efficient delivery of the thousands and thousands of products. Why were these packages delivered by UPS when yesterday it was an amazon branded van driving down the block? Rather than the central information system that lets Amazon function, imagine information tools that help the actors in economies of specificity to coordinate on both local and global scales. If a farm is suddenly unable to supply romaine lettuce to the restaurant that they are contracted with, what other farms can fulfill the order at the last minute? How does the emission of carbon in a specific development project affect the global climate? There are a number of technologies that enable this flexibility and data availability without devolving into extractive systems that require uniformity and cannot handle the uniqueness of these local networks and specific economic relationships. Mutual credit currencies and REA accounting allow for demand side value flows. Peer-to-peer software allows for shared ownership of data, supplanting centralization and silos. And local-first software means these peer networks can operate with a really small minimum viable number of actors or scale up to global levels as needed. Together, along with economies of specificity and other economic and social shifts like cooperatives, it is possible to have the benefits of Amazon and Starbucks without destroying our planet. All while enriching our local communities. Mutual credit currencies Mutual credit currencies REA accounting REA accounting Peer-to-peer Peer-to-peer local-first local-first it is possible to have the benefits of Amazon and Starbucks without destroying our planet. All while enriching our local communities. All while enriching our local communities. Special thanks to my colleagues Camila Hanada, Jarod Holtz, and Paul d’Aoust for their enriching reviews and assistance with this article’s feature image. All mistakes and opinions remain my own. Special thanks to my colleagues Camila Hanada, Jarod Holtz, and Paul d’Aoust for their enriching reviews and assistance with this article’s feature image. All mistakes and opinions remain my own.

Economies of Specificity 

নির্দিষ্টতার অর্থনীতি 

Ökonomien der Spezifität

Economías de especificidad 

Économies de spécificité 

विशिष्टता की अर्थव्यवस्था

特異性の経済

특이성의 경제 

Economias de Especificidade 

Экономия специфичности 

Özgüllük Ekonomileri 

Tính kinh tế của tính đặc thù 

专用经济

How to Set Up a Local DNS Server With Python 

Our users wanted to store app preferences so that every time they use , they can start with the same settings applied. engyne.ai In our case, it was these 3 settings: Author, Publish Status, and Sorting Order. Ideally, once you select these, they should be selected permanently, even if you navigate away or log out. To do this, we decided to build a custom hook that would load and store user preferences from local storage. Since the user can have multiple projects, the preferences should be saved per project. Setting up the Local Storage The name of the key would be: . The subdomain is the project name. For example - engyne-user-prefs-{{subdomain}} engyne-user-prefs-hackernoon. This way, each key would have its own . This type represents the settings that will be stored. UserPrefsType export type UserPrefsType = {
  sortType: string,
  publishingStatusFilter: string,
  authorFilter: string,
} Creating the React Hook Now that we know the key/value to store in the local storage, here’s how we create the React hook called to both save and get value from the local storage. useUserPrefs Note that you can only store strings in the local storage, so all JSON has to be stringified when saving and parsed when retrieving. We also specify a default value in case the project to get the user prefs is not specified. //hooks/useUserPrefs.ts

import { useEffect, useState } from "react";
import { PostPublishStatus, PostSortType } from "/types";

export type UserPrefsType = {
  sortType: string,
  publishingStatusFilter: string,
  authorFilter: string,
}

const defaultUserPrefs: UserPrefsType = {
  sortType: PostSortType.NEWEST,
  publishingStatusFilter: PostPublishStatus.ALL,
  authorFilter: "",
}

const getLocalStorage = (key: string): UserPrefsType => {
  let currentValue;
  try {
    currentValue = JSON.parse(
      localStorage.getItem(key) || JSON.stringify(defaultUserPrefs)
    );
  } catch (error) {
    return defaultUserPrefs;
  }

  return currentValue;
}

const useUserPrefs = (subdomain: string) => {
  const key = `engyne-user-prefs-${subdomain}`

  const [value, setValue] = useState<UserPrefsType>(() => {
    if (!subdomain) return defaultUserPrefs;
    return getLocalStorage(key)
  });

  useEffect(() => {
    if (!subdomain) return;
    const currentValue = getLocalStorage(key);
    setValue(currentValue);
  }, [subdomain])

  useEffect(() => {
    if (!subdomain || !value) return;
    localStorage.setItem(key, JSON.stringify(value))
  }, [value])

  const updateUserPrefs = (userPref: Partial<UserPrefsType>) => {
    if (!subdomain) return;
    const currentValue = getLocalStorage(key);
    const updatedUserPrefs = { ...currentValue, ...userPref }
    setValue(updatedUserPrefs);
  }

  return { userPrefs: value, updateUserPrefs };
};

export default useUserPrefs; Use the Hook in the Application Now, we can import this hook into the application and get the saved author value from the local storage. First, we set up the hook to get the specified project’s user prefs, then we set the author value using the . userPrefs.authorFilter The is used whenever the user selects a different author name. updateUserPrefs import {
  Select,
} from "@chakra-ui/react";

const subdomain = "hackernoon"

const { userPrefs, updateUserPrefs } = useUserPrefs(subdomain)
const authorsData = ["Author 1", "Author 2"]

// in component

<Select size="md" color="gray.600" width="unset" variant="unstyled" placeholder="Select author" onChange={(evt) => {
                  updateUserPrefs({ authorFilter: evt.target.value })
                }} value={userPrefs.authorFilter}>
                  {authorsData.map((author: any, i: number) => (
                    <option key={`author_${i}`} value={author.id}>
                      {author.name}
                    </option>
                  ))}
                </Select> This is what the saved user prefs look like in local storage.

How We Store User Prefs in Local Storage Using Hooks in Next.js

Even with the multitude of libraries available today, it can sometimes be challenging to find one that offers the specific functionality needed for a particular task. Instead of spending time searching for the perfect library, I recommend crafting your own implementation; even if it's tailored specifically for one project. Once, I found myself in need of a library that could easily convert data classes into an Excel document for report generation. When I couldn't locate a suitable library, I decided to develop functionality tailored to my specific needs. My ambition was to design a library akin to Jackson, which would use annotations to transform a list of data classes into an Excel document as dictated by the annotations. I want to share the library I created, hoping it may benefit others or inspire them to create their own mapper for their unique tasks. Let's explore how to develop in Java such a data mapper to achieve this: from this: void demoReport() {
    var excelMapper = new ExcelMapperImpl();

    var fileName = "demo-out-" + LocalTime.now() + ".xlsx";
    List<Demo> demos = generateDemos();

    try (Workbook workbook = excelMapper.createWorkbookFromObject(demos);
         var fileOutputStream = new FileOutputStream(fileName)) {
        workbook.write(fileOutputStream);
    }
} Defining Annotations Let's identify the main elements essential for Excel mapping. At its core, we require an Excel column. This foundational component of the report should distinctly showcase the column name and the corresponding value in each row. Moreover, we must incorporate support for formula cells, allowing us to utilize values and present the results dynamically. At the column's end, a concluding formula is essential, whether it represents an average, sum, or any other pertinent metric for the end-user. Beyond mere data cells, we should also integrate features to easily manage cell styling. After identifying the essential elements, the next step is to craft the necessary annotations. The initial annotation will embed metadata about cell styling. This annotation will encompass fundamental attributes along with their default values: @Retention(RetentionPolicy.RUNTIME)
public @interface ColumnExcelStyle {
    ExcelColumnDataFormat cellTypePattern() default ExcelColumnDataFormat.NONE;
    IndexedColors cellColor() default IndexedColors.AUTOMATIC;

    boolean isWrapText() default false;

    boolean isCentreAlignment() default false;

    boolean isFramed() default true;

    ExcelColumnFont fontName() default ExcelColumnFont.DEFAULT;

    short fontSize() default -1;

    boolean isFontBold() default false;

    ExcelColumnCellTextColor fontColor() default ExcelColumnCellTextColor.AUTOMATIC;
} The primary style elements crucial for report creation are conveyed as attributes. Following this, the initiation of an Excel column annotation can be undertaken: @Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ColumnExcel {
    String[] applyNames() default {};

    int position();

    ColumnExcelStyle headerStyle() default @ColumnExcelStyle(
            fontColor = ExcelColumnCellTextColor.BLACK,
            isCentreAlignment = true,
            isFontBold = true,
            fontSize = 14,
            isWrapText = true);

    ColumnExcelStyle cellStyle() default @ColumnExcelStyle;
} This annotation encompasses potential column names (for mapping from Excel) and a mandatory field - ' '. This will determine the column's placement and be instrumental in formula calculations. Additionally, it will detail the style of both the header and the cell. position Excellent. Now, let's formulate an annotation specific to Excel formulas. Anticipating a dynamic formula contingent on the row's position, this annotation will be exclusive to methods: @Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ColumnExcelFormula {
    String name() default "";

    int position();

    ColumnExcelStyle headerStyle() default @ColumnExcelStyle(
            fontColor = ExcelColumnCellTextColor.BLACK,
            isCentreAlignment = true,
            isFontBold = true,
            fontSize = 14,
            isWrapText = true);

    ColumnExcelStyle cellStyle() default @ColumnExcelStyle;
} Lastly, let’s introduce an annotation for the culminating formula, which typically occupies the final row in Excel, summarizing or illustrating the cumulative result for a column. Given that the formula's annotation also mandates its applicability solely to methods: @Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ColumnExcelTotalFormula {
    boolean useValue() default false;

    int position();

    ColumnExcelStyle cellStyle() default @ColumnExcelStyle;
} Building an Excel Reporting Service With Apache POI After the creation of all necessary annotations, crafting a service class becomes the next step. The core library utilized will be , effective for working with .xls and .xlsx files. This class will use annotations’ attributes to generate an Excel report. Apache POI The primary method accepts a list of objects as input and returns a prepared workbook. For added flexibility, an overloaded method will be introduced to enable the specification of both the file name and the sheet name for report generation: <T> Workbook createWorkbookFromObject(List<T> reportObjects) {
    return createWorkbookFromObject(reportObjects, 0, "Report");
}

<T> Workbook createWorkbookFromObject(List<T> reportObjects, 
                                      int startRowNumber, 
                                      String sheetName) {
...
} To extract information about the class using reflection, any element from the array is selected. After accessing the class details, the first row can be established. Utilizing data from the annotation allows for the creation of cells with their respective names. If a name is absent, the class field's name can serve as an alternative: private <T> void createHeaderFromDeclaredExcelColumns(Row row, Class<T> clazz, PropertyDescriptor propertyDescriptor) {
    try {
        Field field = clazz.getDeclaredField(propertyDescriptor.getName());

        ColumnExcel columnExcel = field.getDeclaredAnnotation(ColumnExcel.class);
        if (nonNull(columnExcel)) {
            String headerName = columnExcel.applyNames().length > 0 ? columnExcel.applyNames()[0] : field.getName();
            createHeader(row, columnExcel.position(), headerName, columnExcel.headerStyle());
        }
    } catch (NoSuchFieldException e) {
        log.debug(e.getLocalizedMessage());
    }
} When fashioning the header, remember to assign a style to every cell. Style parameters can be derived from the annotation: @ColumnExcelStyle private void createHeader(Row row, int position, String name, ColumnExcelStyle columnExcelStyle) {
    Cell cell = row.createCell(position);
    cell.setCellValue(name);

    setCellFormatting(cell, columnExcelStyle);
    row.getSheet().autoSizeColumn(cell.getColumnIndex());
} The process then turns to generating rows in the report based on data from the provided array. By iterating over the data, successive rows are formed: for (T report : reportObjects) {
    Row bodyRow = sheet.createRow(proceedRowNumber);
    createCellsFromDeclaredExcelColumns(bodyRow, report);
    proceedRowNumber++;
} Property descriptors are procured to utilize getters instead of granting direct access to fields: private <T> void createCellsFromDeclaredExcelColumns(Row row, T tObject) {
    try {
        PropertyDescriptor[] propertyDescriptors = Introspector.getBeanInfo(tObject.getClass()).getPropertyDescriptors();

        for (var propertyDescriptor : propertyDescriptors) {
            createCellFromDeclaredExcelColumns(row, tObject, propertyDescriptor);
        }
    } catch (IntrospectionException ex) {
        log.debug(ex.getLocalizedMessage());
    }
} With the property descriptor, a cell is formed: private <T> void createCellFromDeclaredExcelColumns(Row row, T tObject, PropertyDescriptor propertyDescriptor) {
    try {
        Field field = tObject.getClass().getDeclaredField(propertyDescriptor.getName());
        Method readMethod = propertyDescriptor.getReadMethod();

        ColumnExcel columnExcel = field.getDeclaredAnnotation(ColumnExcel.class);
        if (nonNull(columnExcel)) {
            Class<?> returnType = readMethod.getReturnType();
            Cell cell = row.createCell(columnExcel.position());

            Object invokeResult = readMethod.invoke(tObject);
            if (nonNull(invokeResult)) {
                defineAndAssignCellValue(returnType, cell, invokeResult, readMethod);
            }
            setCellFormatting(cell, columnExcel.cellStyle());
        }
    } catch (NoSuchFieldException | InvocationTargetException | IllegalAccessException e) {
        log.debug(e.getLocalizedMessage());
    }
} Next, let’s turn our attention to processing the annotations. Crafting formulas proves slightly more complex than simply extracting a value from a field. A method is expected to generate a formula, which is subsequently assigned to the cell. @ColumnExcelFormula The method should consistently return a string and accept the row number as an argument, ensuring accurate data usage from adjacent cells. Thus, it falls on the handler to verify these conditions are met before forming the cell with the specified formula: private <T> void createCellFromDeclaredExcelFormula(Row row, T tObject, Method readMethod) throws IllegalAccessException, InvocationTargetException {
    ColumnExcelFormula columnExcelFormula = readMethod.getDeclaredAnnotation(ColumnExcelFormula.class);
    if (columnExcelFormula != null) {
        Class<?> returnType = readMethod.getReturnType();
        Cell cell = row.createCell(columnExcelFormula.position());

        if (returnType.isAssignableFrom(String.class)) {
            cell.setCellFormula((String) readMethod.invoke(tObject, row.getRowNum()));
        } else {
            log.debug(" Return type for the method: " + readMethod.getName() + " with @ColumnExcelFormula annotation has to be String " +
                    "and now it's: " + returnType.getName() + " method is ignored for the reason");
        }
        setCellFormatting(cell, columnExcelFormula.cellStyle());
    }
} The final step involves creating a row to display the concluding results. Importantly, this row should be generated only once, irrespective of the number of objects relayed to the handler. An annotation in a static method is anticipated for this purpose. This method receives both the number of the initial row and the current row where the cell will be instantiated as arguments. Provision of the initial row's number is vital, enabling the method to devise a formula that leverages the aggregate result for the entire column: private <T> void createTotalFormula(Class<T> tClazz, Row row, int firstRowNum) {
    Method[] methods = tClazz.getDeclaredMethods();
    for (Method method : methods) {
        ColumnExcelTotalFormula columnExcelTotalFormula = method.getAnnotation(ColumnExcelTotalFormula.class);
        if (columnExcelTotalFormula != null
                && method.getReturnType().isAssignableFrom(String.class)
                && method.getParameters().length == 2
                && Modifier.isStatic(method.getModifiers())
                && !Modifier.isPrivate(method.getModifiers())
        ) {
            String cellFormula = (String) method.invoke(tClazz, firstRowNum, row.getRowNum());
            Cell cell = row.createCell(columnExcelTotalFormula.position());
            cell.setCellFormula(cellFormula);

            if (columnExcelTotalFormula.useValue()) {
                cell = applyFormulasValue(cell);
            }
            setCellFormatting(cell, columnExcelTotalFormula.cellStyle());
        }
    }
} Making a Report The main functionality is now in place, and it's time to see it in action. Let's construct a simple report to demonstrate its operation. For this, let’s create a ' ' class and incorporate all the necessary annotations: Sales @Data
@Accessors(chain = true)
public class Sales {

    @ColumnExcel(
            position = 0, applyNames = {"Date"},
            headerStyle = @ColumnExcelStyle(
                              fontColor = WHITE, 
                              cellColor = DARK_BLUE, 
                              isCentreAlignment = true),
            cellStyle = @ColumnExcelStyle(
                            cellColor = GREY_25_PERCENT, 
                            cellTypePattern = DATE))
    private LocalDate date;

    @ColumnExcel(
            position = 1, applyNames = {"Sold"},
            headerStyle = @ColumnExcelStyle(
                            fontColor = WHITE, 
                            cellColor = DARK_BLUE, 
                            isCentreAlignment = true),
            cellStyle = @ColumnExcelStyle(
                          cellColor = GREY_25_PERCENT))
    private Integer sold;

    @ColumnExcel(
            position = 2, 
            applyNames = {"Price Per Unit (USD)"},
            headerStyle = @ColumnExcelStyle(
                            fontColor = WHITE, 
                            cellColor = DARK_BLUE, 
                            isCentreAlignment = true),
            cellStyle = @ColumnExcelStyle(
                          cellColor = GREY_25_PERCENT, 
                          cellTypePattern = USD))
    private Double pricePerUnit;

    @ColumnExcelFormula(
            position = 3, 
            name = "Total Sales (USD)",
            headerStyle = @ColumnExcelStyle(
                             fontColor = WHITE, 
                             cellColor = DARK_BLUE, 
                             isCentreAlignment = true),
            cellStyle = @ColumnExcelStyle(
                            cellColor = GREY_25_PERCENT, 
                            cellTypePattern = USD))
    public String sales(int rowNum) {
        return new CellAddress(rowNum, 1).formatAsString()
                + "*"
                + new CellAddress(rowNum, 2).formatAsString();
    }

    @ColumnExcelTotalFormula(
            position = 0,
            cellStyle = @ColumnExcelStyle(
                           cellColor = LIGHT_BLUE))
    public static String total(int firstRowNum, int lastRowNum) {
        return "CONCATENATE(\"Total\")";
    }

    @ColumnExcelTotalFormula(
            position = 1,
            cellStyle = @ColumnExcelStyle(
                          cellColor = LIGHT_BLUE))
    public static String unitsSold(int firstRowNum, int lastRowNum) {
        return "SUM(" + new CellAddress(firstRowNum, 1).formatAsString() + ":"
                + new CellAddress(lastRowNum - 1, 1).formatAsString() + ")";
    }


    @ColumnExcelTotalFormula(
            position = 3,
            cellStyle = @ColumnExcelStyle(
                          isCentreAlignment = false, 
                          cellColor = LIGHT_BLUE, 
                          cellTypePattern = USD))
    public static String totalSales(int firstRowNum, int lastRowNum) {
        return "SUM(" + new CellAddress(firstRowNum, 3).formatAsString() + ":"
                + new CellAddress(lastRowNum - 1, 3).formatAsString() + ")";
    }
} The class comprises three fields: , , and . Additionally, it has a sales formula and a concluding line with the totals: and . The fields utilize the annotation, denoting the column's position and name. date sold pricePerUnit unitsSold totalSales @ColumnExcel The annotation defines the style for both the header and individual data cells: @ColumnExcelStyle @ColumnExcel(
        position = 0, 
        applyNames = {"Date"},
        headerStyle = @ColumnExcelStyle(
                          fontColor = WHITE, 
                          cellColor = DARK_BLUE, 
                          isCentreAlignment = true),
        cellStyle = @ColumnExcelStyle(
                          cellColor = GREY_25_PERCENT, 
                          cellTypePattern = DATE)
) As previously discussed, when creating a formula, the method must accept a parameter indicating the row number. This requirement is evident in the method's signature: public String sales(int rowNum) {
        return new CellAddress(rowNum, 1).formatAsString()
                + "*"
                + new CellAddress(rowNum, 2).formatAsString();
    } Given the row number and column indices, crafting any specific formula becomes feasible. Within the class, methods intended for the concluding formulas are static and require two parameters: the starting row's number and the ending row's number: public static String unitsSold(int firstRowNum, int lastRowNum) {
        return "SUM(" + 
                new CellAddress(firstRowNum, 1).formatAsString() + 
                ":" + 
                new CellAddress(lastRowNum - 1, 1).formatAsString() + 
                ")";
    } Now, let's launch the method: void salesReport() {
    var excelMapper = new ExcelMapperImpl();

    var fileName = "sales-out-" + LocalTime.now() + ".xlsx";
    List<Sales> sales = List.of(
                new Sales().setDate(LocalDate.of(2023, 1, 1))
                        .setSold(50)
                        .setPricePerUnit(10d),
                new Sales().setDate(LocalDate.of(2023, 1, 2))
                        .setSold(40)
                        .setPricePerUnit(11d),
                new Sales().setDate(LocalDate.of(2023, 1, 3))
                        .setSold(55)
                        .setPricePerUnit(9d);

    try (Workbook workbook = excelMapper.createWorkbookFromObject(sales);
         var fileOutputStream = new FileOutputStream(fileName)) {
        workbook.write(fileOutputStream);
    }
} And examine the generated report: Conclusion Writing a specialized library for a specific task proved to be straightforward. The library crafted meets the requirements and includes the planned functionality. The approach utilizing annotations facilitates quick and convenient customization of cell styles, modification of formulas, and dynamic report creation from varied data sources. Hence, the next time a suitable library is elusive, considering the development of a personalized one might be beneficial. Naturally, presenting every line of code in this article was not feasible; thus, only the primary methods essential to the mapper's operation were highlighted. The complete code is available on my . GitHub page

From Data Classes to Excel: Building a Java Mapper With Annotations

ডেটা ক্লাস থেকে এক্সেল পর্যন্ত: টীকা সহ একটি জাভা ম্যাপার তৈরি করা

Von Datenklassen bis Excel: Erstellen eines Java-Mappers mit Anmerkungen

De clases de datos a Excel: creación de un asignador de Java con anotaciones

Des classes de données à Excel : créer un mappeur Java avec des annotations

डेटा क्लास से एक्सेल तक: एनोटेशन के साथ जावा मैपर का निर्माण

データ クラスから Excel へ: 注釈を備えた Java マッパーの構築

데이터 클래스에서 Excel까지: 주석을 사용하여 Java 매퍼 구축

Das classes de dados ao Excel: construindo um mapeador Java com anotações

От классов данных к Excel: создание Java Mapper с аннотациями

Veri Sınıflarından Excel'e: Ek Açıklamalarla Java Eşleyici Oluşturma

Từ các lớp dữ liệu đến Excel: Xây dựng trình ánh xạ Java bằng chú thích

从数据类到 Excel：使用注释构建 Java 映射器

( ) is a tool that allows you to run Kubernetes clusters locally using Docker container "nodes". It's a great tool for developers who want to test their applications in a Kubernetes environment without the overhead of a full-scale cluster. K ubernetes in D ocker kind In this blog post, we'll walk through the steps to set up a kind cluster with a Docker registry where you can push the images and pull from the Kubernetes cluster. This will mimic what we would do in Cloud Provider managed Kubernetes clusters i.e. pull the images from OCI registries. We will also look at how to install Ingress and create a service. nginx LoadBalancer Prerequisites Ensure you have the following installed on your machine: Docker , there are many ways to install kind, please refer the link to install as you see fit. kind , we will use this to interact with the cluster. kubectl All the scripts discussed in this blog are uploaded to this . github repository What are we going to create? Multi-node kubernetes cluster with and nodes. Examples of worker nodes with and . control-plane worker labels taints Create a local registry to push and pull locally built docker images Deploy so that we can access the endpoints exposed by the services Ingress Validate the setup by installing pods with dummy services This setup is pretty much what you need to validate your applications locally, this setup will be extremely helpful and cost-efficient while developing services for Kubernetes environment. Create k8s cluster with multiple nodes and configure cluster with containerd registry config dir The following is the with and nodes. The and other control plane components will be on the node with role . And nodes with role will have your pods. You will observe the , , , , , , and pods will be deployed on the control-plane node by default. Cluster cluster-config.yaml control-plane worker api-server control-plane worker controller-manager api-server scheduler etcd coredns kindnet kube-proxy local-path-provisioner The worker nodes will have and by default. You will also observe that we are configuring the cluster with registry config. kindnet kube-proxy containerd We are also exposing ports 80/443/5678 so that can hit those ports from the machine. localhost kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
name: "platformwale"
# configure cluster with containerd registry config dir enabled
containerdConfigPatches:
- |-
  [plugins."io.containerd.grpc.v1.cri".registry]
    config_path = "/etc/containerd/certs.d"
nodes:
# control plane node
# this comes with taint so that control-plane node will not accept any other pods by default
- role: control-plane
  image: "kindest/node:v1.27.3"

# worker nodes

# worker with no node labels, so pods with no nodeSelectors will schedule here
- role: worker
  image: "kindest/node:v1.27.3"

# worker with node label role=app
# pods with nodeSelectors role=app will schedule here
- role: worker
  image: "kindest/node:v1.27.3"
  labels:
    role: app

# worker with node label role=ingress
# pods with nodeSelectors role=ingress and toleration to taint role=ingress:NoSchedule will schedule here
- role: worker
  image: "kindest/node:v1.27.3"
  labels:
    role: ingress
  # extraPortMappings allow the localhost to make requests to the Ingress controller over ports 80/443/5678
  extraPortMappings:
  - containerPort: 80
    hostPort: 80
    protocol: TCP
  - containerPort: 443
    hostPort: 443
    protocol: TCP
  - containerPort: 5678
    hostPort: 5678
    protocol: TCP
  # add taint to the node such that only pods tolerating the taint will be scheduled on this node
  kubeadmConfigPatches:
  - |
    kind: JoinConfiguration
    nodeRegistration:
      kubeletExtraArgs:
        register-with-taints: "role=ingress:NoSchedule" Create the cluster by submitting the file as follows - kind cluster-config.yaml kind create cluster --config cluster-config.yaml You will see something that looks like what’s displayed below on the successful creation of a kind cluster - $ kind create cluster --config cluster-config.yaml
Creating cluster "platformwale" ...
 ✓ Ensuring node image (kindest/node:v1.27.3) 🖼
 ✓ Preparing nodes 📦 📦 📦 📦
 ✓ Writing configuration 📜
 ✓ Starting control-plane 🕹️
 ✓ Installing CNI 🔌
 ✓ Installing StorageClass 💾
 ✓ Joining worker nodes 🚜
Set kubectl context to "kind-platformwale"
You can now use your cluster with:

kubectl cluster-info --context kind-platformwale

Have a question, bug, or feature request? Let us know! https://kind.sigs.k8s.io/#community 🙂

$ kubectl cluster-info --context kind-platformwale
Kubernetes control plane is running at https://127.0.0.1:58931
CoreDNS is running at https://127.0.0.1:58931/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'. Validate that you can see the kind cluster you created above - $ kind get clusters
platformwale Validate that the nodes are created successfully - $ kubectl get nodes
NAME                         STATUS   ROLES           AGE     VERSION
platformwale-control-plane   Ready    control-plane   9m20s   v1.27.3
platformwale-worker          Ready    <none>          8m55s   v1.27.3
platformwale-worker2         Ready    <none>          9m1s    v1.27.3
platformwale-worker3         Ready    <none>          8m56s   v1.27.3 Please read this documentation to learn more options to configure the KIND cluster. configuration Create the registry container and configure cluster nodes for the registry Create the registry container and configure the cluster nodes for registry access as below. This command will pull the container locally and will start the container. This container will be used as the local docker registry. registry # start the registry container
reg_name='kind-registry'
reg_port='5001'
if [ "$(docker inspect -f '{{.State.Running}}' "${reg_name}" 2>/dev/null || true)" != 'true' ]; then
  docker run \
    -d --restart=always -p "127.0.0.1:${reg_port}:5000" --name "${reg_name}" \
    registry:2
fi Now add the registry config to the nodes as below. This is necessary because localhost resolves to loopback addresses that are network-namespace local. In other words, localhost in the container is not localhost on the host. We want a consistent name that works from both ends, so we tell containerd to alias to the registry container when pulling images. localhost:${reg_port} kind_cluster_name="platformwale"
reg_port='5001'
REGISTRY_DIR="/etc/containerd/certs.d/localhost:${reg_port}"
for node in $(kind get nodes --name ${kind_cluster_name}); do
  docker exec "${node}" mkdir -p "${REGISTRY_DIR}"
  cat <<EOF | docker exec -i "${node}" cp /dev/stdin "${REGISTRY_DIR}/hosts.toml"
[host."http://${reg_name}:5000"]
EOF
done Now connect the registry to the cluster network, this allows kind to bootstrap the network and ensure they are on the same network. reg_name='kind-registry'
if [ "$(docker inspect -f='{{json .NetworkSettings.Networks.kind}}' "${reg_name}")" = 'null' ]; then
  docker network connect "kind" "${reg_name}"
fi Now document the local registry. The standard of defining the local registry is defined in detail in this . This is a standard way for cluster configuration tools to record how developer tools should interact with the local registry as well as a standard way for developer tools to read that information when pushing images to the cluster. doc reg_port='5001'
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: ConfigMap
metadata:
  name: local-registry-hosting
  namespace: kube-public
data:
  localRegistryHosting.v1: |
    host: "localhost:${reg_port}"
    help: "https://kind.sigs.k8s.io/docs/user/local-registry/"
EOF At this point you have finished creating the cluster as well enabled a local docker registry. Connect to the Private Registry We will pull a sample app from the remote docker registry, tag it and push it to the local registry we created above. We will then start the pod using the image pulled from the local registry. Here's an example: # pull a sample hello-app from remote registry
docker pull gcr.io/google-samples/hello-app:1.0

# tag the pulled docker image for local registry
docker tag gcr.io/google-samples/hello-app:1.0 localhost:5001/hello-app:1.0

# push the docker image to the local registry
docker push localhost:5001/hello-app:1.0 Submit following yaml to create deployment to use the docker image from the local registry. hello-server hello-app kubectl apply -f - <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: hello-server
  name: hello-server
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: hello-server
  template:
    metadata:
      labels:
        app: hello-server
    spec:
      nodeSelector:
        role: app
      containers:
      - image: localhost:5001/hello-app:1.0
        imagePullPolicy: IfNotPresent
        name: hello-app
EOF Validate that the pod is running successfully as below and it runs on node as we have used - platformwale-worker2 nodeSelector: role=app $ kubectl get po -n default -o wide
NAME                           READY   STATUS    RESTARTS   AGE   IP           NODE                   NOMINATED NODE   READINESS GATES
hello-server-bfc485c98-jzxbb   1/1     Running   0          14s   10.244.2.3   platformwale-worker2   <none>           <none> This proves that we have a working kubernetes cluster with multiple nodes as well as we are able to push and pull images from local docker registry. The local registry can also be used for . For instance, you have a big local or setup which pulls huge images, you can setup this local registry on one of the hosted machines in your office network, and then all the engineers in your team can use this registry to pull the images to setup the local environment instead of pulling from a public network. This will speed up the environment setup as well as save the network bandwidth. bootstrapping local development environments faster vagrant docker-compose Deploy Ingress and validate LoadBalancer k8s service In this section, we will deploy Ingress service on the nodepool we created earlier. We will also deploy k8s service along with sample apps to validate the deployment. nginx ingress LoadBalancer nginx We have modified the public to tolerate and use to deploy the nginx pods on node which we have configured with taints and label such that we only deploy the deployments. Use the modified as below - nginx deploy.yaml taint -> role:ingress:NoSchedule nodeSelector -> role=ingress platformwale-worker3 nginx nginx.yaml kubectl apply -f https://raw.githubusercontent.com/piyushjajoo/kind-with-local-registry-and-ingress/master/nginx.yaml Validate all the pods are running - nginx $ kubectl get pods -n ingress-nginx -o wide
NAME                                        READY   STATUS      RESTARTS   AGE   IP           NODE                   NOMINATED NODE   READINESS GATES
ingress-nginx-admission-create-4kxmk        0/1     Completed   0          34m   10.244.1.2   platformwale-worker3   <none>           <none>
ingress-nginx-admission-patch-kx4zv         0/1     Completed   1          34m   10.244.1.3   platformwale-worker3   <none>           <none>
ingress-nginx-controller-57d7c6cb58-g2gdf   1/1     Running     0          34m   10.244.1.4   platformwale-worker3   <none>           <none> Pull the following docker image to the local registry, we will use it for the setup validation as below - Ingress # pull docker image
docker pull hashicorp/http-echo:0.2.3

# tag the image for local registry
docker tag hashicorp/http-echo:0.2.3 localhost:5001/http-echo:0.2.3

# push the docker image
docker push localhost:5001/http-echo:0.2.3 This will also install loadbalancer. NOTE: On macOS and Windows, docker does not expose the docker network to the host. Because of this limitation, containers (including kind nodes) are only reachable from the host via port-forwards, however,s other containers/pods can reach other things running in docker including loadbalancers. If you are on Mac or Windows, you can skip installing . MetalLB MetalLB # install metallb
echo "install metallb"
kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.13.7/config/manifests/metallb-native.yaml

# wait until MetalLB pods (controller and speaker) are ready
echo "wait until MetalLB pods (controller and speaker) are ready"
kubectl wait --namespace metallb-system \
                --for=condition=ready pod \
                --selector=app=metallb \
                --timeout=90s

# find the cidr range for kind network
echo "find the cidr range for the kind network"
output=$(docker network inspect -f '{{.IPAM.Config}}' kind)

ipv4_cidr=$(echo "$output" | grep -oE '([0-9]+\.[0-9]+)\.[0-9]+\.[0-9]+/[0-9]+' | head -n 1)
ipv4_parts=$(echo "$ipv4_cidr" | cut -d '.' -f 1,2)

echo "IPv4 CIDR Range (First 2 Parts): $ipv4_parts"

# configure ip address pool
echo "configuring ip address pool"
kubectl apply -f - <<EOF
apiVersion: metallb.io/v1beta1
kind: IPAddressPool
metadata:
  name: example
  namespace: metallb-system
spec:
  addresses:
  - $ipv4_parts.255.200-$ipv4_parts.255.250
---
apiVersion: metallb.io/v1beta1
kind: L2Advertisement
metadata:
  name: empty
  namespace: metallb-system
EOF Validate the object using services as well as validate type service using the script below. You can skip creating type service below if you are on Mac or Windows. Ingress ClusterIP LoadBalancer LoadBalancer The script below will deploy pods and setup object to divert the traffic to the pods based on configured. Ingress path kubectl apply -f - <<EOF
kind: Pod
apiVersion: v1
metadata:
  name: foo-app
  labels:
    name: foo-app
    app: http-echo
spec:
  containers:
  - name: foo-app
    image: localhost:5001/http-echo:0.2.3
    args:
    - "-text=foo"
---
kind: Pod
apiVersion: v1
metadata:
  name: bar-app
  labels:
    name: bar-app
    app: http-echo
spec:
  containers:
  - name: bar-app
    image: localhost:5001/http-echo:0.2.3
    args:
    - "-text=bar"
---
kind: Service
apiVersion: v1
metadata:
  name: foo-service
spec:
  selector:
    name: foo-app
  ports:
  # Default port used by the image
  - port: 5678
---
kind: Service
apiVersion: v1
metadata:
  name: bar-service
spec:
  selector:
    name: bar-app
  ports:
  # Default port used by the image
  - port: 5678
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /$2
spec:
  rules:
  - http:
      paths:
      - pathType: Prefix
        path: /foo(/|$)(.*)
        backend:
          service:
            name: foo-service
            port:
              number: 5678
      - pathType: Prefix
        path: /bar(/|$)(.*)
        backend:
          service:
            name: bar-service
            port:
              number: 5678
---
kind: Service
apiVersion: v1
metadata:
  name: foo-service-lb
spec:
  type: LoadBalancer
  selector:
    name: foo-app
    app: http-echo
  ports:
  # Default port used by the image
  - port: 5678
---
kind: Service
apiVersion: v1
metadata:
  name: bar-service-lb
spec:
  type: LoadBalancer
  selector:
    name: bar-app
    app: http-echo
  ports:
  # Default port used by the image
  - port: 5678
---
EOF Validate the as below - Ingress # validate cluster ips via Ingress object
# should output "foo-app"
echo "validating foo-app via Ingress object"
curl localhost/foo/hostname
# should output "bar-app"
echo "validating bar-app via Ingress object"
curl localhost/bar/hostname Validate the service as below, if you are on Mac or Windows, as mentioned earlier docker doesn't expose the docker network to the host, hence you won't be able to use the IP directly instead you will need to port forward the service to access. LoadBalancer LoadBalancer ## on linux you can validate LoadBalancer as below

# validate load balancer service
echo "validating loadbalancer, note on macOS and Windows, docker does not expose the docker network to the host. Because of this limitation, containers (including kind nodes) are only reachable from the host via port-forwards, however other containers/pods can reach other things running in docker including loadbalancers"

FOO_LB_IP=$(kubectl get svc/foo-service-lb -n default -o=jsonpath='{.status.loadBalancer.ingress[0].ip}')

BAR_LB_IP=$(kubectl get svc/bar-service-lb -n default -o=jsonpath='{.status.loadBalancer.ingress[0].ip}')

# should output foo and bar on separate lines 
for _ in {1..10}; do
  curl ${FOO_LB_IP}:5678
  curl ${BAR_LB_IP}:5678
done


## on Mac or Windows port-forward and hit the service as below

# validate foo-service-lb
kubectl port-forward -n default svc/foo-service-lb 5678:5678

# in browser hit localhost:5678 or do curl as below, you will see foo as output
$ curl localhost:5678
foo

# validate bar-service-lb
kubectl port-forward -n default svc/bar-service-lb 5678:5678

# in browser hit localhost:5678 or do curl as below, you will see bar as output
$ curl localhost:5678
bar To setup on Mac using MetalLB refer this LoadBalancer documentation Cleanup Destroy the cluster as well as as below - kind registry # delete kind cluster
echo "deleting kind cluster"
kind delete cluster --name "platformwale"

# delete registry
echo "deleting registry"
docker rm -f $(docker ps -a | grep registry | awk -F ' ' '{print $1}') Conclusion And that's it! You now have a local Kubernetes development environment with a local Docker registry. This setup allows you to build, push, and deploy your Docker images without needing to push them to a public registry. This is useful in setting up local development environments faster and save network bandwidth. You also installed service to create k8s service, this is useful to mimic the LoadBalancer behavior as you might need to do in an actual cloud provider. Ingress LoadBalancer Resources kind documentation kind resources All the scripts and yamls are uploaded in this github repository MetalLB docs Kind and MetalLB on mac Originally published at on Aug 15, 2023. https://platformwale.blog Author Notes Feel free to reach out with any concerns or questions you have. I will make every effort to address your inquiries and provide resolutions. Stay tuned for the upcoming blog in this series dedicated to Platformwale (Engineers who work on Infrastructure Platform teams).

Kubernetes Cluster Setup with a Local Registry and Ingress in Docker using KIND 

In the ever-evolving landscape of cyber threats, ransomware has proven to be one of the most notorious and damaging forms of attack. Among the various ransomware variants, RagnarLocker has garnered significant attention for its sophisticated tactics and impact on critical infrastructure sectors. In this blog post, we delve into the world of RagnarLocker ransomware, exploring its indicators of compromise (IOCs), technical intricacies, and the havoc it wreaks on targeted systems. 💥🔓 Ransomware Strikes Israeli Hospital: Ragnar_Locker Takes Responsibility 🏥 In a chilling turn of events, RagnarLocker’s menace struck closer to home as it targeted Mayanei Hayeshua Medical Center in Bnei Brak, Israel a few days ago. The ransomware attack wreaked havoc on the hospital’s administrative computer systems. The aftermath was devastating — medical treatments were disrupted, and the emergency room was compelled to redirect patients to other hospitals for urgent care. Emerging from the chaos, Ragnar_Locker took responsibility for this audacious attack. However, I’ve made a detailed investigation that yielded no signs of any leaked data or information on the group’s Onion site or Telegram group. This marks an unusual departure from the norm, where cybercriminals often flaunt their exploits on such platforms. This incident serves as a grim reminder of the vulnerabilities lurking in critical infrastructure sectors, with healthcare being no exception. It underscores the pressing need for fortified cybersecurity measures to shield essential services from such malicious onslaughts. As the investigation into this unsettling event progresses, the global cybersecurity community will undoubtedly be closely monitoring further developments. 🌐🔒🦠 The Emergence of RagnarLocker 🌄💻 The first traces of RagnarLocker ransomware came to light in April 2020, catching the attention of cybersecurity experts and organizations worldwide. Notably, the Federal Bureau of Investigation (FBI) issued an initial report detailing known IOCs associated with RagnarLocker. Over time, this ransomware variant has evolved, refining its obfuscation techniques and evading traditional detection methods. 🚀🔍 A Persistent Threat 🎯🌐 As of January 2022, the FBI has identified over 52 entities spanning across 10 critical infrastructure sectors affected by RagnarLocker ransomware. These sectors encompass critical manufacturing, energy, financial services, government, and information technology, underscoring the ransomware’s indiscriminate targeting. 💼🏢🔒 Technical Insights 🔍💡 Ransom Note and Identification: RagnarLocker is recognizable by the “.RGNR_<ID>” extension appended to encrypted files. The actors, self-identifying as “RAGNAR_LOCKER,” accompany this extension with a .txt ransom note, containing instructions for payment and data decryption. 💰🔐📄 Advanced Packing Techniques: The ransomware employs advanced techniques like VMProtect, UPX, and custom packing algorithms, adding layers of complexity to its execution. This obfuscation serves to complicate detection efforts. 🧩🔒🔍 Geographical Targeting: RagnarLocker uses the Windows API GetLocaleInfoW to identify the infected machine’s location. If the victim’s location falls within certain geopolitical areas, the ransomware terminates its processes, potentially hinting at the attackers’ geopolitical motivations. 🗺️🌍🔍 Selective Encryption: Instead of opting for a widespread encryption approach, RagnarLocker selectively encrypts files. It designates folders it won’t encrypt, allowing the system to function “normally” while encrypting files with valuable data. This method minimizes disruptions while maximizing the potential payout. 📁🔒🤖 Before encryption, Ragnar Locker spawns the following child processes: This system command deletes all shadow copies on the victim’s system, preventing data recovery by the victim : wmic.exe shadowcopy delete This system command also deletes shadow copies, preventing data recovery by the victim : vssadmin delete shadows /all /quiet This command launches Notepad.exe to show the ransom note to the victim. : notepad.exe [User path]\RGNR_AABBCCDD.txt After the ransom note is created, the actual file encryption process initiates using the __ __algorithm. It excludes files ending in . Salsa20 db, .sys, .dll, lnk, .msi, .drv and .exe. Neutralizing Defenses 🛡️🚫 Service Termination: RagnarLocker goes a step further in its attack strategy by identifying and terminating services commonly used by managed service providers (MSPs) for remote network administration. This further hampers recovery efforts. 💔🔧 Shadow Copy Deletion: Preventing victim recovery efforts, the ransomware erases Volume Shadow Copies, a mechanism used to restore files to previous states. The malware employs various methods, including >vssadmin delete shadows /all /quiet and >wmic.exe.shadowcopy.delete. 🗑️🔮 Conclusion 📢🔐 RagnarLocker ransomware presents a multifaceted threat that combines advanced technical techniques with an intricate attack strategy. Its evolution since its discovery in 2020, along with its targeting of critical infrastructure sectors, underscores the urgency of bolstering cybersecurity measures to defend against this and similar threats. As organizations and security experts continue to dissect RagnarLocker’s mechanisms, it becomes increasingly evident that the fight against ransomware demands a proactive and collaborative approach, where vigilance and innovation go hand in hand. 🛡️🌐🔒 References: https://www.timesofisrael.com/liveblog_entry/bnei-brak-hospital-bracing-for-release-of-sensitive-patient-information-after-hack/ https://www.ic3.gov/Media/News/2022/220307.pdf https://www.linkedin.com/showcase/dailydarkweb/ https://www.pcrisk.com/removal-guides/17018-ragnar-locker-ransomware Also published . here

Uncovering Ragnar_Locker Ransomware: Exploring IOCs

Last week, we described the concept behind : you forward a request to the same upstream because there's context data associated with the session on that node. However, if necessary, you should replicate the data to other upstreams because this one might go down. In this post, we are going to illustrate it with a demo. sticky sessions Content Overview The overall design The heart of the application Configuring Spring Session with Hazelcast Configuring Spring Security Putting our design to the test Conclusion The overall design Design options are limitless. I'll keep myself to a familiar stack, the JVM. Also, as mentioned in the previous post, one should only implement sticky sessions with session replication. The final design consists of two components: an instance with sticky sessions configured and two JVM nodes running the same application with session replication. Apache APISIX The application uses the following: Dependency Description Spring Boot Eases the usage of Spring libraries Spring MVC Allows offering HTTP endpoints Thymeleaf View technology Spring Session Offers an abstraction over session replication Hazelcast (embedded) Implements session replication Spring Security Binds an identity to a user session The design looks like the following: and are two instances of the same app; I didn't want to overcrowd the diagram with redundant data. app1 app2 The heart of the application The heart of the application is a session-scoped bean that wraps a counter, which can only be incremented: @Component
@SessionScope
public class Counter implements Serializable {              //1

    private int value = 0;

    public int getValue() {
        return value;
    }

    public void incrementValue() {
        value++;
    }
} Necessary for Hazelcast serialization to work We can use this bean in the controller: @Controller
public class IndexController {

    private final Counter counter;

    public IndexController(Counter counter) {               //1
        this.counter = counter;
    }

    @GetMapping("/")
    public String index(Model model) {                      //2
        counter.incrementValue();
        model.addAttribute("counter", counter.getValue());
        return "index";
    }
} Inject the session-scoped bean in the singleton controller thanks to Spring's magic When we send a request to the root, increment the counter value and pass it to the model GET Finally, we display the bean's value on the Thymeleaf page: <!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org" lang="en">
<body>
<div th:text="${counter}">3</div> Configuring Spring Session with Hazelcast Spring Session offers a filter that wraps the original to override the method. This method returns a specific implementation backed by the implementation configured with Spring Session, in our case, HttpServletRequest getSession() Session Hazelcast. We need only a few tweaks to configure Spring Session with Hazelcast. First, annotate the Spring Boot application class with the relevant annotation: @SpringBootApplication
@EnableHazelcastHttpSession
public class SessionApplication {
    ...
} Hazelcast requires a specific configuration as well. We can use XML, YAML, or code. Since it's a demo, I can choose whatever I want, so let's code it. Spring Boot requires either an Hazelcast object or a configuration object. The latter is enough: @Bean
public Config hazelcastConfig() {
  var config = new Config();
  var networkConfig = config.getNetworkConfig();
  networkConfig.setPort(0);                                                      //1
  networkConfig.getJoin().getAutoDetectionConfig().setEnabled(true);              //2
  var attributeConfig = new AttributeConfig()                                     //3
          .setName(HazelcastIndexedSessionRepository.PRINCIPAL_NAME_ATTRIBUTE)
          .setExtractorClassName(PrincipalNameExtractor.class.getName());
  config.getMapConfig(HazelcastIndexedSessionRepository.DEFAULT_SESSION_MAP_NAME) //3
          .addAttributeConfig(attributeConfig)
          .addIndexConfig(new IndexConfig(
            IndexType.HASH,
            HazelcastIndexedSessionRepository.PRINCIPAL_NAME_ATTRIBUTE
  ));
  var serializerConfig = new SerializerConfig();
  serializerConfig.setImplementation(new HazelcastSessionSerializer())            //3
                  .setTypeClass(MapSession.class);
  config.getSerializationConfig().addSerializerConfig(serializerConfig);
  return config;
} Choose a random port to avoid port conflict Allow Hazelcast to search for other instances and automagically form a cluster. It's going to be necessary when deployed as per our design Copy-pasted from the Spring Session documentation Configuring Spring Security Most Spring Session examples somehow use Spring Security, and though it's not strictly necessary, it makes the design easier. I want to explain why first. One can think about sessions as a gigantic hash table. In regular applications, the key is the cookie value, the value, and another hash table of session data. However, the is specific to the node. The app will give a different if one uses another node. Since the key is different, there's no way to access the session data, even if the session data is shared across nodes. To prevent this loss, we need to come up with a different key. Spring Security allows using a principal (or the login name) as the session data key. JSESSIONID JSESSIONID JSESSIONID Here's how I set up a basic Spring Security configuration: @Bean
public SecurityFilterChain securityFilterChain(UserDetailsService service, HttpSecurity http) throws Exception {
  return http.userDetailsService(service)                                    //1
             .authorizeHttpRequests(authorize -> authorize.requestMatchers(
                 PathRequest.toStaticResources().atCommonLocations())        //2
                            .permitAll()                                     //2
                            .anyRequest().authenticated()                    //3
             ).formLogin(form -> form.permitAll()
                                     .defaultSuccessUrl("/")                 //4
             ).build();
} The default in-memory user details service doesn't allow custom user details classes. I had to provide my own. Allow everybody to access static resources at "common" locations All other requests must be authenticated Allow everybody to access the authentication form Redirect to the root if successful, which maps the above controller Putting our design to the test Besides the counter, I want to display two additional pieces of data: the hostname and the logged-in user. For the hostname, I add the following method to the controller: @ModelAttribute("hostname")
private String hostname() throws UnknownHostException {
    return InetAddress.getLocalHost().getHostName();
} Displaying the logged-in user requires an additional dependency: <dependency>
    <groupId>org.thymeleaf.extras</groupId>
    <artifactId>thymeleaf-extras-springsecurity6</artifactId>
</dependency> On the page, it's straightforward: <!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org"
      xmlns:sec="http://www.thymeleaf.org/extras/spring-security">  
<body>
<td sec:authentication="principal.label">Me</td>                     Add the namespace. It's not necessary but may help the IDE to help you sec Require the underlying implementation to have a method UserDetail getLabel() Last but not least, we need to configure Apache APISIX with sticky sessions, as we saw last week: routes:
  - uri: /*
    upstream:
      nodes:
        "webapp1:8080": 1
        "webapp2:8080": 1
      type: chash
      hash_on: cookie
      key: cookie_JSESSIONID
#END Here's the design implemented on Docker Compose: services:
  apisix:
    image: apache/apisix:3.3.0-debian
    volumes:
      - ./apisix/config.yml:/usr/local/apisix/conf/config.yaml:ro
      - ./apisix/apisix.yml:/usr/local/apisix/conf/apisix.yaml:ro    #1
    ports:
      - "9080:9080"                                                  #2
    depends_on:
      - webapp1
      - webapp2
  webapp1:
    build: ./webapp
    hostname: webapp1                                                #3
  webapp2:
    build: ./webapp
    hostname: webapp2                                                #3 Use the previous configuration file Only expose the API Gateway to the outside world Set the hostname to display it on the page We can log in using one of the two hard-coded accounts. I'm using , with password and label . Notice that Apache APISIX sets me on a node and keeps using the same if I refresh. john john John Doe We can try to log in with the other account ( / ) from a private window and check the counter starts from 0. jane jane Now comes the fun part. Let's stop the node which should be hosting the session data, here and refresh the page: webapp2 docker compose stop webapp2 We can see exciting things in the logs. Apache APISIX can no longer find the , so it forwards the request to the other upstream that it knows, . webapp2 webapp1 The request is still authenticated; it goes through Spring Security The framework gets the principal out of the request It queries Spring Session And gets the correct counter value that Hazelcast replicated from the other node The only side-effect is an increased latency because of Apache APISIX timeout. It's 5 seconds by default, but you can configure it to a lower value if needed. When we start again, everything works as expected again. webapp2 Conclusion In this post, I described a possible setup for sticky sessions with Apache APISIX and replication involving the Spring ecosystem and Hazelcast. Many other options are available depending on your stack and framework of choices. The complete source code for this post can be found on . GitHub To go further: Spring Session and Spring Security with Hazelcast Spring Session Hazelcast Originally published at on July 2nd, 2023 A Java Geek

Stories, News & Mentions about GETLOCAL

Getlocal’s Stories on HackerNoon

Getlocal's News & Mentions